logger

Logger

This is a standard logger implemented using uber's zap package. We have internally dabbled between using logrus and zap and arrived at using zap. Log responsibly :)

Features

• Supports creating standalone logger and logging
• Support for adding default keys
• Support for adding custom keys
• Support for key value pair chaining
• Support for creating and fetching from context
• Built in sentry implementation using zap core
• Ability to register additional zap cores as extensions
• Ability to redact value for field based on field passed in secureLogField or fields tagged with piifield:true in struct.

Getting Started

Note: Please refer to the examples folder to see all the use cases

Import the logging package

Create the logger configuration

lgrConfig = logger.Config{
            		LogLevel: logger.Debug, //Look below for the list of debug levels
            		SentryDSN:       "", // In case you want sentry integration, this is the DSN
            		SentryEnabled:   false, // Again, for sentry integration
            		SentryFlushTimeoutInSeconds: 5 // Sentry waits until any buffered events are sent to the Sentry server, blocking for at most the given timeout
            		SentryLogLevel:  "", // For what minimum log level do you want a sentry trigger?
            		ContextString: "context" // Default value. Any additional context variables will have this as the default key. See Section on  additional debugging information below
            	}

Initialize the logger

lgr := logger.NewLogger(lgrConfig)

Starting to log(Standard methods , Debug,Info, Warn, Error, Panic, Fatal)

lgr.Debug("Hello")
...
lgr.Warn("Warning")
...

Usage Examples

Configure with some default keys at bootstrap

defaultLogger := lgr.WithFields(map[string]interface{}{"key1": "value1"})
defaultLogger.Debug("I have the default values for Key1 and Value1")

Configure defaults from golang context

ctxLogger := lgr.WithContext(myctx, []string{"myctxfield1", "myctxfield2")
ctxLogger.Debug("I have default values configured with golang context")

Adding additional custom debugging information

defaultLogger.Debugw("This will log the url too besides key and value above", map[string]interface{}{"url":"http://example.com"})

Field Chaining

lgr := logger.NewLogger(lgrConfig)
defaultLogger := lgr.WithFields(map[string]interface{}{"key1": "value1"}).Withfields(map[string]interface{"key2":"value2"}).Debug("Another message")

With custom error handling

lgr := logger.NewLogger(lgrConfig)
lgr.WithContext(myctx, []string{"myctxfield1", "myctxfield2").WithError(errors.New("Doomed here")).Debug("Error message")

Combining all the above

lgr := logger.NewLogger(lgrConfig)
lgr.WithFields(map[string]interface{}{"key1": "value1"}).Withfields(map[string]interface{"key2":"value2"}).WithError(errors.New("Doomed here")).Debug("Error message")

Set and retrieve logger from context

ctxLogger := lgr.WithContext(myctx, []string{"myctxfield1", "myctxfield2")
ctx := context.WithValue(myctx, logger.LoggerCtxKey, ctxLogger)
......

fromContextLogger, err := logger.Ctx(ctx)
if err != nil {
    fmt.Printf("Error obtaining logger from context")
    os.Exit(1)
}
fromContextLogger.Debug("Logging obtained from existing context")

Apply options to logger

lgr := logger.NewLogger(lgrConfig)

lgr.WithOptions(logger.AddCallerSkip(2)).Debug("Modified logger skip level")

Different log levels for different modules

By default, the entire logger runs at a single logLevel. If you want different modules of the application to run at different log Levels, you can use NewModuleLogger function for passing logger to that module

Here is a sample implementation

config := logger.Config{
  LogLevel:        logger.Error,
  SentryEnabled:   false,
}
outboxLogger, _ := logger.NewModuleLogger(config)
ouboxer := outbox.New(outboxConfig, outboxStore, outboxLogger.WithContext(ctx, nil), mutexClient, encoder, nil)

This way the app can run at info log level whereas the outbox module can run at error level

Suppose the app is running at info log level and for a particular request you want to print the debug logs as well, you can use debug mode. This way all logs are printed irrespective of the log level they are written at.

debugMode := r.Header.Get(DebugModeHeaderKey)
if debugMode == "true" {
  lgr.EnableDebugMode()
}
ctx = context.WithValue(ctx, logger.LoggerCtxKey, lgr)

This should ideally be done in request level middleware or request hooks

TODO

1. Better mechanism to expose and build custom cores