binarylog

Documentation

Overview

Package binarylog implementation binary logging as defined in https://github.com/grpc/proposal/blob/master/A16-binary-logging.md.

Index

• Variables
• func SetLogger(l Logger)
• type Cancel
• type ClientHalfClose
• type ClientHeader
• type ClientMessage
• type LogEntryConfig
• type Logger
  • func GetLogger() Logger
  • func NewLoggerFromConfig(config LoggerConfig) Logger
  • func NewLoggerFromConfigString(s string) Logger
• type LoggerConfig
• type MethodLogger
  • func GetMethodLogger(methodName string) MethodLogger
• type MethodLoggerConfig
• type ServerHeader
• type ServerMessage
• type ServerTrailer
• type Sink
  • func NewBufferedSink(o io.WriteCloser) Sink
• type TruncatingMethodLogger
  • func NewTruncatingMethodLogger(h, m uint64) *TruncatingMethodLogger
  • func (ml *TruncatingMethodLogger) Build(c LogEntryConfig) *binlogpb.GrpcLogEntry
  • func (ml *TruncatingMethodLogger) Log(c LogEntryConfig)

Variables

var (
	// AllLogger is a logger that logs all headers/messages for all RPCs. It's
	// for testing only.
	AllLogger = NewLoggerFromConfigString("*")
	// MdToMetadataProto converts metadata to a binary logging proto message.
	// It's for testing only.
	MdToMetadataProto = mdToMetadataProto
	// AddrToProto converts an address to a binary logging proto message. It's
	// for testing only.
	AddrToProto = addrToProto
)

Functions

func SetLogger

func SetLogger(l Logger)

SetLogger sets the binary logger.

Only call this at init time.

Types

type Cancel

type Cancel struct {
	OnClientSide bool
}

Cancel configs the binary log entry to be a Cancel entry.

type ClientHalfClose

type ClientHalfClose struct {
	OnClientSide bool
}

ClientHalfClose configs the binary log entry to be a ClientHalfClose entry.

type ClientHeader

type ClientHeader struct {
	OnClientSide bool
	Header       metadata.MD
	MethodName   string
	Authority    string
	Timeout      time.Duration
	// PeerAddr is required only when it's on server side.
	PeerAddr net.Addr
}

ClientHeader configs the binary log entry to be a ClientHeader entry.

type ClientMessage

type ClientMessage struct {
	OnClientSide bool
	// Message can be a proto.Message or []byte. Other messages formats are not
	// supported.
	Message interface{}
}

ClientMessage configs the binary log entry to be a ClientMessage entry.

type LogEntryConfig

type LogEntryConfig interface {
	// contains filtered or unexported methods
}

LogEntryConfig represents the configuration for binary log entry.

type Logger

type Logger interface {
	GetMethodLogger(methodName string) MethodLogger
}

Logger is the global binary logger. It can be used to get binary logger for each method.

func GetLogger

func GetLogger() Logger

GetLogger gets the binary logger.

Only call this at init time.

func NewLoggerFromConfig

func NewLoggerFromConfig(config LoggerConfig) Logger

NewLoggerFromConfig builds a logger with the given LoggerConfig.

func NewLoggerFromConfigString

func NewLoggerFromConfigString(s string) Logger

NewLoggerFromConfigString reads the string and build a logger. It can be used to build a new logger and assign it to binarylog.Logger.

Example filter config strings:

• "" Nothing will be logged
• "*" All headers and messages will be fully logged.
• "*{h}" Only headers will be logged.
• "*{m:256}" Only the first 256 bytes of each message will be logged.
• "Foo/*" Logs every method in service Foo
• "Foo/*,-Foo/Bar" Logs every method in service Foo except method /Foo/Bar
• "Foo/*,Foo/Bar{m:256}" Logs the first 256 bytes of each message in method /Foo/Bar, logs all headers and messages in every other method in service Foo.

If two configs exist for one certain method or service, the one specified later overrides the previous config.

type LoggerConfig

type LoggerConfig struct {
	All      *MethodLoggerConfig
	Services map[string]*MethodLoggerConfig
	Methods  map[string]*MethodLoggerConfig

	Blacklist map[string]struct{}
}

LoggerConfig contains the config for loggers to create method loggers.

type MethodLogger

type MethodLogger interface {
	Log(LogEntryConfig)
}

MethodLogger is the sub-logger for each method.

func GetMethodLogger

func GetMethodLogger(methodName string) MethodLogger

GetMethodLogger returns the MethodLogger for the given methodName.

methodName should be in the format of "/service/method".

Each MethodLogger returned by this method is a new instance. This is to generate sequence id within the call.

type MethodLoggerConfig

type MethodLoggerConfig struct {
	// Max length of header and message.
	Header, Message uint64
}

MethodLoggerConfig contains the setting for logging behavior of a method logger. Currently, it contains the max length of header and message.

type ServerHeader

type ServerHeader struct {
	OnClientSide bool
	Header       metadata.MD
	// PeerAddr is required only when it's on client side.
	PeerAddr net.Addr
}

ServerHeader configs the binary log entry to be a ServerHeader entry.

type ServerMessage

type ServerMessage struct {
	OnClientSide bool
	// Message can be a proto.Message or []byte. Other messages formats are not
	// supported.
	Message interface{}
}

ServerMessage configs the binary log entry to be a ServerMessage entry.

type ServerTrailer

type ServerTrailer struct {
	OnClientSide bool
	Trailer      metadata.MD
	// Err is the status error.
	Err error
	// PeerAddr is required only when it's on client side and the RPC is trailer
	// only.
	PeerAddr net.Addr
}

ServerTrailer configs the binary log entry to be a ServerTrailer entry.

type Sink

type Sink interface {
	// Write will be called to write the log entry into the sink.
	//
	// It should be thread-safe so it can be called in parallel.
	Write(*binlogpb.GrpcLogEntry) error
	// Close will be called when the Sink is replaced by a new Sink.
	Close() error
}

Sink writes log entry into the binary log sink.

sink is a copy of the exported binarylog.Sink, to avoid circular dependency.

var (
	// DefaultSink is the sink where the logs will be written to. It's exported
	// for the binarylog package to update.
	DefaultSink Sink = &noopSink{} // TODO(blog): change this default (file in /tmp).
)

func NewBufferedSink

func NewBufferedSink(o io.WriteCloser) Sink

NewBufferedSink creates a binary log sink with the given WriteCloser.

Write() marshals the proto message and writes it to the given writer. Each message is prefixed with a 4 byte big endian unsigned integer as the length.

Content is kept in a buffer, and is flushed every 60 seconds.

Close closes the WriteCloser.

type TruncatingMethodLogger

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

TruncatingMethodLogger is a method logger that truncates headers and messages based on configured fields.

func NewTruncatingMethodLogger

func NewTruncatingMethodLogger(h, m uint64) *TruncatingMethodLogger

NewTruncatingMethodLogger returns a new truncating method logger.

func (*TruncatingMethodLogger) Build

func (ml *TruncatingMethodLogger) Build(c LogEntryConfig) *binlogpb.GrpcLogEntry

Build is an internal only method for building the proto message out of the input event. It's made public to enable other library to reuse as much logic in TruncatingMethodLogger as possible.

func (*TruncatingMethodLogger) Log

func (ml *TruncatingMethodLogger) Log(c LogEntryConfig)

Log creates a proto binary log entry, and logs it to the sink.