zapsentry

README

Sentry client for zap logger

Integration of sentry client into zap.Logger is pretty simple:

func modifyToSentryLogger(log *zap.Logger, DSN string) *zap.Logger {
	cfg := zapsentry.Configuration{
		Level: zapcore.ErrorLevel, //when to send message to sentry
		EnableBreadcrumbs: true, // enable sending breadcrumbs to Sentry
		BreadcrumbLevel: zapcore.InfoLevel, // at what level should we sent breadcrumbs to sentry
		Tags: map[string]string{
			"component": "system",
		},
	}
	core, err := zapsentry.NewCore(cfg, zapsentry.NewSentryClientFromDSN(DSN))

	// to use breadcrumbs feature - create new scope explicitly
	log = log.With(zapsentry.NewScope().Build())

	//in case of err it will return noop core. so we can safely attach it
	if err != nil {
		log.Warn("failed to init zap", zap.Error(err))
	}
	return zapsentry.AttachCoreToLogger(core, log)
}

Documentation

Index

• func AttachCoreToLogger(sentryCore zapcore.Core, l *zap.Logger) *zap.Logger
• func FromScope(scope *sentry.Scope) zapcore.Field
• func NewCore(cfg Configuration, factory SentryClientFactory) (zapcore.Core, error)
• type ClientGetter
• type Configuration
• type LevelEnabler
  • func (l *LevelEnabler) Enabled(lvl zapcore.Level) bool
• type Scope
  • func NewScope() *Scope
  • func (s *Scope) Apply(sf ScopeFunc) *Scope
  • func (s *Scope) Build() zapcore.Field
  • func (s *Scope) SetRequest(r *http.Request) *Scope
  • func (s *Scope) SetTag(key, value string) *Scope
  • func (s *Scope) SetTags(tags map[string]string) *Scope
  • func (s *Scope) SetUser(user sentry.User) *Scope
• type ScopeFunc
• type SentryClientFactory
  • func NewSentryClientFromClient(client *sentry.Client) SentryClientFactory
  • func NewSentryClientFromDSN(DSN string) SentryClientFactory

Examples

• AttachCoreToLogger

Functions

func AttachCoreToLogger

func AttachCoreToLogger(sentryCore zapcore.Core, l *zap.Logger) *zap.Logger

Example

package main

import (
	"fmt"
	"log"
	"time"

	"github.com/getsentry/sentry-go"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"go.uber.org/zap/zaptest/observer"

	"github.com/dhillondeep/zapsentry"
)

func main() {
	// Setup zap with observer (for testing), originally we use
	// 		config = zap.NewDevelopmentConfig()
	//  	logger, err := config.Build()
	// to build zap logger, here we use zap/zaptest/observer for testing
	core, recordedLogs := observer.New(zapcore.DebugLevel)
	logger := zap.New(core, zap.AddStacktrace(zap.DebugLevel))

	// Setup mock sentry client for testing, in general we use sentry.NewClient
	var recordedSentryEvent *sentry.Event
	sentryClient := mockSentryClient(func(event *sentry.Event) {
		recordedSentryEvent = event
	})

	// Setup zapsentry
	core, err := zapsentry.NewCore(zapsentry.Configuration{
		Level:             zapcore.ErrorLevel, // when to send message to sentry
		EnableBreadcrumbs: true,               // enable sending breadcrumbs to Sentry
		BreadcrumbLevel:   zapcore.InfoLevel,  // at what level should we sent breadcrumbs to sentry
		Tags: map[string]string{
			"component": "system",
		},
	}, zapsentry.NewSentryClientFromClient(sentryClient))
	if err != nil {
		log.Fatal(err)
	}
	newLogger := zapsentry.AttachCoreToLogger(core, logger)

	// Send error log
	newLogger.
		With(zapsentry.NewScope()).
		Error("[error] something went wrong!", zap.String("method", "unknown"))

	// Check output
	fmt.Println(recordedLogs.All()[0].Message)
	fmt.Println(recordedSentryEvent.Message)
	fmt.Println(recordedSentryEvent.Extra)
}

func mockSentryClient(f func(event *sentry.Event)) *sentry.Client {
	client, _ := sentry.NewClient(sentry.ClientOptions{
		Dsn:       "",
		Transport: &transport{MockSendEvent: f},
	})
	return client
}

type transport struct {
	MockSendEvent func(event *sentry.Event)
}

// Flush waits until any buffered events are sent to the Sentry server, blocking
// for at most the given timeout. It returns false if the timeout was reached.
func (f *transport) Flush(_ time.Duration) bool { return true }

// Configure is called by the Client itself, providing it it's own ClientOptions.
func (f *transport) Configure(_ sentry.ClientOptions) {}

// SendEvent assembles a new packet out of Event and sends it to remote server.
// We use this method to capture the event for testing
func (f *transport) SendEvent(event *sentry.Event) {
	f.MockSendEvent(event)
}

Output:

[error] something went wrong!
[error] something went wrong!
map[method:unknown]

func FromScope

func FromScope(scope *sentry.Scope) zapcore.Field

FromScope adds scope provided to field

func NewCore

func NewCore(cfg Configuration, factory SentryClientFactory) (zapcore.Core, error)

Types

type ClientGetter

type ClientGetter interface {
	GetClient() *sentry.Client
}

type Configuration

type Configuration struct {
	Tags              map[string]string
	DisableStacktrace bool
	Level             zapcore.Level
	BreadcrumbLevel   zapcore.Level
	EnableBreadcrumbs bool // this feature works only when you explicitly passed new scope
	FlushTimeout      time.Duration
	Hub               *sentry.Hub
}

Configuration is a minimal set of parameters for Sentry integration.

type LevelEnabler

type LevelEnabler struct {
	zapcore.Level
	// contains filtered or unexported fields
}

func (*LevelEnabler) Enabled

func (l *LevelEnabler) Enabled(lvl zapcore.Level) bool

type Scope

type Scope struct {
	// contains filtered or unexported fields
}

Scope is abstraction over sentry.Scope

func NewScope

func NewScope() *Scope

NewScope creates a new Scope object

func (*Scope) Apply

func (s *Scope) Apply(sf ScopeFunc) *Scope

Apply applies direct changes to the underlying scope

func (*Scope) Build

func (s *Scope) Build() zapcore.Field

Build constructs a zapcore.Field object from the current scope

func (*Scope) SetRequest

func (s *Scope) SetRequest(r *http.Request) *Scope

SetRequest sets the request on the underlying scope

func (*Scope) SetTag

func (s *Scope) SetTag(key, value string) *Scope

SetTag sets a tag on the underlying scope

func (*Scope) SetTags

func (s *Scope) SetTags(tags map[string]string) *Scope

SetTags sets the tags on the underlying scope

func (*Scope) SetUser

func (s *Scope) SetUser(user sentry.User) *Scope

SetUser sets the user on the underlying scope

type ScopeFunc

type ScopeFunc func(scope *sentry.Scope)

ScopeFunc is a function that can be used to apply changes to the underlying scope

type SentryClientFactory

type SentryClientFactory func() (*sentry.Client, error)

func NewSentryClientFromClient

func NewSentryClientFromClient(client *sentry.Client) SentryClientFactory

func NewSentryClientFromDSN

func NewSentryClientFromDSN(DSN string) SentryClientFactory