Changing dmd to implement `in` meaning `scope const` when DIP1000 is
selected causes Phobos to fail to compile. This changes Phobos in
preparation for that change.
Log message currently doesn't have log level, thread ID, etc. Log messages
without this information is mostly useless.
However, printing the thread ID requires std.concurrency to be @safe
which is not possible at the moment. So I've added only the log level to
the message string.
The DDOX based documentation is configured to only show entities with doc comments and thus hides modules without one. This adds an empty comment to all public Phobos modules that have stayed undocumented so far.
They should probably get a proper documentation with description/license/copyright/.... This just fixes the documentation until then.
This reverts commit 299f0183e2661cb2640749a692a3463a0e51c1f9.
thread local forward
thread local default log function forward
nicer imports
forwardMsg must not be final
moved comments to package and started to integerade Martin's log disabling
more compile time function disabling
style and dscanner suggestions
stdThreadLog fix and doc
a lot of updates
* spell fixes
* better tests
* docu changes
docu update
whitespace
moduleLogLevel docu
Allows logging objects with @system toString
To compensate the change unittest blocks where marked as @safe where
applicable
Remove concurrency @trusted workarounds
Relevant druntime PR has been merged, plain @safe works now
Fix safety of logger.core
Replaces @trusted abuse with @safe annotations and few occasional
@trusted tweaks.
Improve safety of all logger
Cleans usage of @safe and @trusted in derived modules
Abstract methods have to be marked 'abstract', or the compiler wont complain about missing implementations, but instead assume they will be in some .o file that is later passed to the linker.
Made reads/writes to globalLogLevel atomic and separated global log level from stdlog's log level.
(Had to add a cast to the first array element of LogLevel arrays in foreach(). Possibly a compiler bug in 2.066 master.)
Avoid races with reading/writing the standard Logger:
* User code can no longer directly read out the stdlog, because by the time it has the reference, it might already be obsolete. (Later an `opApply` style function could be provided to execute functions/delegates in the context of a locked stdlog.)
* The stdlog property was split up into a public setter `stdlog` and a package getter `stdlogImpl`, because the compiler doesn't like different visibility for getter and setter.
* All module level functions dealing with the stdlog now synchronize with the global `__stdloggermutex`.
static assert(__ctfe) doesn't do what one might expect. Code is always generated and emitted for `isLoggingActive` and it can be called at runtime. This commit turns the template function into just a template `isLoggingActiveAt` and a global bool flag `isLoggingActive`, so they can both be evaluated without parenthesis now and don't end up as functions in the final executable.
Fix: Unittesting symbols like randomString() are visible outside of the logger package.
Changed Logger methods to `final`, that are not documented as overridable to gain more control over the implementation details when I implement thread safety measures.
Made `fatalHandler` accessible as a property to allow synchronization in later commits.
Also made `writeLogMsg` protected, so it can assume it is properly synchronized already by the public calls calling it.
To log a pre-built message `forwardMsg` can now be used. (See `FileLogger`).
Fixed my mistake, where setting `stdlog` before querying `stdlogImpl` would revert the setting. And while I was at it, I changed `stdlog`s behavoir on assignment of `null`: It will now put the default logger back in place.
First attempt on making logging thread safe: Logger now has a mutex to protect its public API.
The module level functions don't perform any runtime checks themselves to avoid races.
Instead the logger does all checking under protection of its mutex.
`globalLogLevel` will be evaluated only once for any public logging call and thus needs no global locking.
All overrides of `writeLogMsg`, `beginLogMsg`, `logMsgPart` and `finishLogMsg` have `protected` visibility now, since they expect their logger to be already under mutex protection and must not be publically visible.
Fixed `MultiLogger` to not perform checks for its children to avoid races.
Small fix for `StdLoggerDisableLogging`.
some more unittests and some fixes
doc fixes
doc fix MrSmith33
Array problem
stupid me
stupid me
The getter for Logger.logLevel now uses an `atomicLoad` instead of full mutex lock.
Read-access to `stdlog` is now back...
Fixed inverted DDoc meaning for `isLoggingActive`.
Removed synchronization with a global lock for the duration of any standard logging call in an exchange of sequential consinstency for throughput.
Rejects valid: logf(LogLevel.fatal, "I am %s", true);
(The template constraint is not required in this case.)
Fix for `template isLoggingActive` that would break if an actual log level was disabled.
some more docu fixes
fatel -> fatal
changed the way of calling
some rework
some better comments and win32.mak fix
more documentation
trying to figure out why win32 fails
test before you commit
another try to work around windows files and processes
maybe this time
maybe this merges
update 1 mostly soenke
MultiLogger and Logger have names
more docu
unittest fix
some better comments and win32.mak fix
Conflicts:
std/logger.d
antoher doc fix
less code dup and more log functions
docs are now generated
some more fixing
speedup
some threading
forgot some
better docu gen and more testing
two new LogLevel, most functions are now at least @trusted
Tracer functionality
fatal delegate
some phobos style fixes
another bug bites the dust
version disable enhancements
default global LogLevel set to LogLevel.all
logLevel compare bugfix
delete of dead code
tab to whitespace
bugfixes, reduandency removal, and docu
multilogger was logging to all it childs without checking there LogLevel in
relation to the LogLevel of the LoggerPayload.
Some constructors where redundant.
more examples and more documentation
some fixes
NullLogger and moduleName
wrong doc
I splitted the multi logger implementations out
loglevelF to loglevelf in order to make phobos style think writefln
document building
win makefile fixes
some optimizations thanks to @elendel-
some whitespace
some updates from the github logger project
* stdio- and filelogger now use a templatelogger base to reduce code
makefile fixes
makefile
fixed the unittest
made sure the stdiologger is set up at the end
some comment fixes
finding the filelogger segfault
closed another file
a lookup fix
darwin unittest fail output
more diagnostics
* more documentation for the templatelogger and multilogger
* it breaks the log function api
* log and logf now behave as their write and writef counterparts
* for logging with an explicit LogLevel call logl loglf
* for logging with an explicit condition call logc logcf
* for logging with an explicit LogLevel and explicit condition call
* loglc loglcf
* the log function with an explicit LogLevel like info, warning, ...
* can be extended into c, f or cf and therefore require a condition
* and/or are printf functions
something is still interesting
rebase and lazy Args
saver file handling
whitespace
some updates
tracer is gone and more doc updates
codegen rework to allow log function comments
thread safe and concur works comments for free standing log functions
fixes#10
* free log function doco
* StdIOLogger prints now threadsafe
* concurrentcy hang fix
more docu
old file
even more doc
typo
* more better doc
* makefile fix
another fix
more unittests nearl 100% everywhere
another test
no more mixins more doc
win64 please pass
fixes from the review and voting
hope this fixes it
more comments
more docs more tests
more docu
more doc and fixes from jacob-carlborg
LogEntry.logger reference
more fixes
fileptr is gone
logger move to experimental/logger
type in win32/64 makefile
win makefile
nogc and threading
makefile fixes
some log calls take line and file as parameter
