Skip to content

Latest commit

 

History

History
120 lines (108 loc) · 6.76 KB

roadmap.md

File metadata and controls

120 lines (108 loc) · 6.76 KB
Raw

The Future of Stumpless

See below for details about upcoming releases of Stumpless. If you have feedback or want to make a suggestion, please submit an issue on the project's Github page.

2.2.0

  • [ADD] Target chaining In some cases a log message needs to be sent to multiple destinations, such as to a local file as well as a network server. Target chains will allow this stream to be defined as a logging target, and a logging call only made to this instead of manually logging to each target.
  • [ADD] Improved network target error detection Network targets do not currently detect errors that they would be able to in some cases, such as with select or poll. This may lead to a connection being left open for longer than necessary if the error is already detected. This change will improve error detection in network targets to reduce the time needed to pass these errors on to callers.

3.0.0 (next major release)

  • [REMOVE] entry and element destructor synonyms Removing previously deprecated feature.
  • [REMOVE] Stream target constructor using int facility Removing previously deprecated feature.
  • [CHANGE] Python language bindings to Wrapture instead of SWIG The Wrapture project is being built to provide clean, readable, and explicit language binding functionality from C to other target languages, specifically to support Stumpless. Once Python is added as a target language, this will be utilized to create the associated library bindings, replacing SWIG and removing the dependency. In the future, other language bindings will be added using Wrapture as they are added to the tool.
  • [CHANGE] Implement asynchronous logging modes Asynchronous logging can provide significantly less latency to the calling application. This will provide more benefit to some targets than others, most notably network-based targets. Because some error reporting mechanisms may need to change to accomodate this, it will be done in a major release.
  • [CHANGE] Error enum values start from 1 instead of 0 This will allow function that return negative integers in error scenarios to pass along a more meaningful return value.
  • [CHANGE] Entry app name and msgid no longer NULL-terminated. Improve efficiency and memory safety by only using these as byte buffers.

Unallocated to a release

  • [ADD] Ruby language bindings
  • [ADD] C# language bindings
  • [ADD] TCL language bindings
  • [ADD] Java language bindings
  • [ADD] Powershell language bindings
  • [ADD] Perl language bindings
  • [ADD] AWS/S3 logging target
  • [ADD] Database logging target
  • [ADD] REST endpoint logging target
  • [ADD] Hyperledger/blockchain logging target
  • [ADD] Ability to limit the rate of logging (per message, per byte)
  • [ADD] Logging target for Windows Debug log
  • [ADD] Configuration file support Many other logging solutions provide a way to configure logging via a separate configuration file that defines targets and their options. Stumpless will likely not implement it's own format, but rather add the ability to load the configuration files from other such tools to provide equivalent capabilities. This will also need to include an ability to retrieve a target by name, enforce uniqueness of names, and include other changes that require it to be done in a major release.

What you'll find here and what you wont

Stumpless is under active development, and has a long list of new features and improvements waiting to be implemented. Some of these are detailed in the issues list on the project Github website, but this is certainly not a comprehensive list of planned updates. Similarly, work that is in progress on new features is tracked as a project on the Github repository, but future planned work does not exist there either. Instead, the plans for future direction are kept here, in the project roadmap.

Items are added to the roadmap once they have been identified, assessed for level of effort, and prioritized based on community needs. Each item is assigned to a semantic version, along with its change type, a description, and the reasoning behind it. Where they exist, you will see references to issues on the Github repository where you can go for more details on the origin of the request. Once a version is in work, you will be able to find a corresponding project on the Github repository with each roadmap item listed as a task. Once all tasks are complete, the version will be released and the next started.

Once an item has been implemented it will be removed from the roadmap. If you would like to see a history of changes on the existing codebase, check out the ChangeLog (ChangeLog.md in the project root) to see what was included in each version of the library. In most cases, roadmap items will be removed from this document and placed there upon completion.

Note that the timelines associated with each change are vague at best. The project team is not currently big enough to realistically make any promises, so timing is often left out to prevent folks from feeling cheated if something takes longer than expected.

A Note about Github issues and projects

A fair question to ask is why the roadmap is not being managed within the issue and project features of Github itself, since this is where the project is currently hosted. Indeed, suggestions submitted by the community are tracked as issues, and projects are already created for ongoing work. There are a few reasons that a separate roadmap is maintained:

  • Issues are used to exclusively track bugs and community requests. This certainly isn't a hard and fast rule, and isn't followed by many other projects, but it is how Wrapture is managed. Keeping the issue count as a clear indicator of known problems and community requests lets the project maintainers (and anyone interested in looking at how well it is being maintained) immediately see how much outstanding work exists. Of course, the roadmap may have features requested by the community or enhancements made clear by bug reports, but it will also have a number of features and tweaks that have a lower priority.
  • Project direction should come packaged with the product. Again this isn't a commonly followed rule, but it is one that the project author follows. Anyone that obtains the source code of the project at a single point in time should be able to quickly see the current direction of the project. Maintaining the roadmap within the version control of the source itself facilitates this, the same way that licensing and copyright notifications are traditionally bundled with code. And if you don't care, you can always ignore them.