xybor-x / xylog Goto Github PK

Problem

• Cloned by #19
• Some variables are used with high frequently. Allocate these variable is time-consuming.

Solution
Use pool.

Describe the bug

• Affected version: v0.1.0
• Logger Flush only Flush its Emitters. It should Flush parent Emitters too.

To Reproduce
Steps to reproduce the behavior:

1. Create Logger named "parent" with a Handler and a Emitter.
2. Create Logger named "parent.child" without Handler.
3. Log one message with the "parent.child" Logger.
4. Terminate the program and check the output.

Expected behavior
The output should have the message, but not found.

Problem
Because we do not have an easy way to config a root logger, it is redundant.

Solution
Remove root logger methods.

Problem
Sometimes we use a third party library which uses xylog, and we need to flush the Emitter in the library too.

Solution
Flush should be the global function instead of Logger method. It need to flush all emitters in program.

Problem
Currently, log with an object, map, or array is too slow.

Solution
Consider add fast encoding of object, map, and array.

Problem
Socket is a requirement of a logging library.

Solution
Add SocketEmitter.

Problem
NewRotatingEmitter functions need to many arguments, it make code difficult to readable.

Solution
Initiate RotatingEmitter via a config struct instead of using New functions with parameters.

Example

var config = &TimeEmitterConfig{
    Filename: "example.log",
    BackupCount: 5,
    Interval: 5*time.Minute
}

var emitter = NewFileEmitter(config)

Problem

• Almost unittests are too useless.
• They use ExpectNotPanic to only get code coverage without any logic check.

Solution
Rewrite unittests.

Problem
Currently, creating a logger is take too many lines of code. We need to shorten this work.

Solution
Create a wrapper logger which allows to set the output and format quickly.

Example

var simpleConfig = xylog.NewSimpleConfig("example.service")
simpleConfig.SetTextFormatter("%(message)s %(asctime)s")
simpleConfig.SetOutput(os.Stdout)

var logger = xylog.GetLogger("example.service")
logger.Info("something")

Problem
uber/zaplog has a very fast way of encoding logging messages. They build by themself the logging message instead of using json.Marshal.

Add copyright to all files

Describe the bug

• Affected version: v0.3.0

=== RUN   TestLoggerCallHandlerHierarchy
/home/runner/work/xylog/xylog/logger_test.go:107: "This is a long enough message 26" IN messsage="This is a long enough message 268"

To Reproduce
Steps to reproduce the behavior:

1. Two random messages are the same prefix.

Expected behavior
Test passes.

Problem
using AddField we can add permanent fields. But sometimes the values of the field change over the time. As of now there is no way to fix this as you cannot delete the logger object (no api) and can remove/ update field (no api).
Sometime some fields are no longer required so there should be a provision to remove the fields.

Solution

1. allow recreating the logger object
2. allow updating and removing field bye key

Example

logger := xylog.GetLogger(name)
logger.AddField("test", "sample1")

logger.UpdateField("test", "sample2")
logger.RemoveField("test")

Problem
Many people need to know some information about this library.

Solution
Add Q&A

Problem
Handler is used to create logging message, and Emitter is used to dispatch messages to specific output.
One logging message could be printed to some output.

Solution
Handler need to have some Emitters instead of one.

Describe the bug

• Affected version:v0.2.0
• Misspelling.

Problem
One Logger can have some Handlers with different formatters. Currently, EventLogger must specify the format (JSON or default) of fields. It is difficult to handle in the logger with both JSONFormatter and StructuredFormatter.

Solution
Adapt EventLogger fields with Formatter.

Problem
String concatenation is time-consuming and produce many allocations.

Solution
Use array of byte as buffer instead.

Problem
Linux has a logrotate command line tool for handle rotating log files. Moreover, Rotating Emitters are difficult to maintain and extend. It should be removed.

Solution

• Remove Rotating Emitters.
• Consider to create a logrotate in Golang for handling rotating log files on multiplatform.

Problem
Benchmark is using the utility functions in tests package. It is hard to maintain this package.

Problem
When logging a message by using bufio.Writer, it is appended to the buffer. If Emitter calls Writer.Flush, the bytes in buffer will be written into disk files. This creates an IO bound time.

Solution

• Do not Flush as soon as writing.
• Create Close methods for writing unflushed bytes to destination.

Example

var emitter = xylog.NewStreamEmitter(os.Stdout)
defer emitter.Close()

Problem
Now a Handler has many Emitters, it is time-consuming if locking while the Handler call Emit of all Emitters.

Solution
Emitter should have its own lock.

Problem
EventLogger contains many fields, if we allocate theses fields every call, it will time-consuming.

Solution
Create pool to reuse EventLogger.

Problem

• Cloned by #19
• Zap and zerolog uses a approach of blazing fast encoding. It encodes the json without using reflect or fmt.Sprint.

Solution
Apply this approach to TextFormatter.

Describe the bug

• Affected version: v0.1.0
• Xybor standard format is not correct as example.

To Reproduce
Steps to reproduce the behavior:

var logger = xylog.GetLogger("xybor.foo")
logger.Debug("bar")

Output is:

time=[time] level=DEBUG message=bar

Expected behavior
Example says it should print:

time=[time] source=example.go.main:2 level=DEBUG module=foo message=bar

Screenshots
No.

Environment

• OS: all.

Additional context
Add any other context about the problem here.

Problem

• Cloned by #19
• Zap and zerolog uses a approach of blazing fast encoding. It encodes the json without using reflect or fmt.Sprint.

Solution
Apply this approach to JSONFormatter.

Problem
The alone benchmark values do not prove anything.

Solution
Add benchmark of some logging libraries:

• Python logging.
• logrus.
• zaplog.