message

package
v0.0.0-...-863240d Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 14, 2022 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Overview

package message defines the Composer interface and a handful of implementations which represent the structure for messages produced by grip.

Message Composers

The Composer interface provides a common way to define messages, with two main goals:

1. Provide a common interface for representing structured and unstructured logging data regardless of logging backend or interface.

2. Provide a method for *lazy* construction of log messages so they're built *only* if a log message is over threshold.

The message package also contains many implementations of Composer which should support most logging use cases. However, any package using grip for logging may need to implement custom composer types.

The Composer implementations in the message package compose the Base type to provide some common functionality around priority setting and data collection.

The logging methods in the Journaler interface typically convert all inputs into a reasonable Composer implementations.

Error Messages

The error message composers underpin the Catch<> logging messages, which allow you to log error messages but let the logging system elide logging for nil errors.

Functional Messages

Grip can automatically convert three types of functions into messages: 

func() Fields
func() Composer
func() error

The benefit of these functions is that they're only called if the message is above the logging threshold. In the case of conditional logging (i.e. When), if the conditional is false, then the function is never called.

in the case of all the buffered sending implementation, the function call can be deferred and run outside of the main thread, and so may be an easy way to defer message production outside in cases where messages may be complicated.

Additionally, the message conversion in grip's logging method can take these function types and convert them to these messages, which can clean up some call-site operations, and makes it possible to use defer with io.Closer methods without wrapping the method in an additional function, as in: 

defer grip.Error(file.Close)

Although the WrapErrorFunc method, as in the following may permit useful annotation, as follows, which has the same "lazy" semantics. 

defer grip.Error(message.WrapErrorFunc(file.Close, message.Fields{}))

Bytes Messages

The bytes types make it possible to send a byte slice as a message.

Stack Messages

The Stack message Composer implementations capture a full stacktrace information during message construction, and attach a message to that trace. The string form of the message includes the package and file name and line number of the last call site, while the Raw form of the message includes the entire stack. Use with an appropriate sender to capture the desired output.

All stack message constructors take a "skip" parameter which tells how many stack frames to skip relative to the invocation of the constructor. Skip values less than or equal to 0 become 1, and are equal the call site of the constructor, use larger numbers if you're wrapping these constructors in our own infrastructure.

In general Composers are lazy, and defer work until the message is being sent; however, the stack Composers must capture the stack when they're called rather than when they're sent to produce meaningful data.

Index

Constants

View Source 
const FieldsMsgName = "message"

FieldsMsgName is the name of the default "message" field in the fields structure.

Variables

This section is empty.

Functions

func GetDefaultFieldsMessage 

func GetDefaultFieldsMessage(msg Composer, val string) string

GetDefaultFieldsMessage returns a "short" message form, to avoid needing to call .String() on the type, which produces a string form of the message. If the message has a short form (either in the map, or separate), it's returned, otherwise the "val" is returned.

For composers not that don't wrap Fields, this function will always return the input value.

func IsStructured 

func IsStructured(msg Composer) bool

IsStructured returns false if the Composer has a string form which is merely a representation of the structured form.

Additionally, returns true for all unknown types, including all types not produced by this package.

Types

type Base 

type Base struct {
	Level    level.Priority `bson:"level,omitempty" json:"level,omitempty" yaml:"level,omitempty"`
	Hostname string         `bson:"hostname,omitempty" json:"hostname,omitempty" yaml:"hostname,omitempty"`
	Time     time.Time      `bson:"time,omitempty" json:"time,omitempty" yaml:"time,omitempty"`
	Process  string         `bson:"process,omitempty" json:"process,omitempty" yaml:"process,omitempty"`
	Pid      int            `bson:"pid,omitempty" json:"pid,omitempty" yaml:"pid,omitempty"`
	Context  Fields         `bson:"context,omitempty" json:"context,omitempty" yaml:"context,omitempty"`
}

Base provides a simple embedable implementation of some common aspects of a message.Composer. Additionally the Collect() method collects some simple metadata, that may be useful for some more structured logging applications.

func (*Base) Annotate 

func (b *Base) Annotate(key string, value interface{}) error

Annotate makes it possible for callers and senders to add structured data to a message. This may be overridden for some implementations

func (*Base) Collect 

func (b *Base) Collect() error

Collect records the time, process name, and hostname. Useful in the context of a Raw() method.

func (*Base) IsZero 

func (b *Base) IsZero() bool

IsZero returns true when Base is nil or it is non-nil and none of its fields are set.

func (*Base) Priority 

func (b *Base) Priority() level.Priority

Priority returns the configured priority of the message.

func (*Base) SetPriority 

func (b *Base) SetPriority(l level.Priority) error

SetPriority allows you to configure the priority of the message. Returns an error if the priority is not valid.

type Composer 

type Composer interface {
	// Returns the content of the message as a string for use in
	// line-printing logging engines.
	String() string

	// A "raw" format of the logging output for use by some Sender
	// implementations that write logged items to interfaces that
	// accept JSON or another structured format.
	Raw() interface{}

	// Returns "true" when the message has content and should be
	// logged, and false otherwise. When false, the sender can
	// (and should!) ignore messages even if they are otherwise
	// above the logging threshold.
	Loggable() bool

	// Annotate makes it possible for Senders and Journalers to
	// add structured data to a log message. May return an error
	// when the key alrady exists.
	Annotate(string, interface{}) error

	// Priority returns the priority of the message.
	Priority() level.Priority
	SetPriority(level.Priority) error
}

Composer defines an interface with a "String()" method that returns the message in string format. Objects that implement this interface, in combination to the Compose[*] operations, the String() method is only caled if the priority of the method is greater than the threshold priority. This makes it possible to defer building log messages (that may be somewhat expensive to generate) until it's certain that we're going to be outputting the message.

func CollectAllProcesses 

func CollectAllProcesses() []Composer

CollectAllProcesses returns a slice of populated ProcessInfo message.Composer interfaces for all processes currently running on a system.

func CollectBasicGoStats 

func CollectBasicGoStats() Composer

CollectBasicGoStats returns some very basic runtime statistics about the current go process, using runtime.MemStats and runtime.NumGoroutine.

The data reported for the runtime event metrics (e.g. mallocs, frees, gcs, and cgo calls,) are the counts since the last time metrics were collected, and are reported as rates calculated since the last time the statics were collected.

Values are cached between calls, to produce the deltas. For the best results, collect these messages on a regular interval.

Internally, this uses message.Fields message type, which means the order of the fields when serialized is not defined and applications cannot manipulate the Raw value of this composer.

The basic idea is taken from https://github.com/YoSmudge/go-stats.

func CollectGoStatsDeltas 

func CollectGoStatsDeltas() Composer

CollectGoStatsDeltas constructs a Composer, which is a GoRuntimeInfo internally, that contains data collected from the Go runtime about the state of memory use and garbage collection.

The data reported for the runtime event metrics (e.g. mallocs, frees, gcs, and cgo calls,) are the counts since the last time metrics were collected.

Values are cached between calls, to produce the deltas. For the best results, collect these messages on a regular interval.

func CollectGoStatsRates 

func CollectGoStatsRates() Composer

CollectGoStatsRates constructs a Composer, which is a GoRuntimeInfo internally, that contains data collected from the Go runtime about the state of memory use and garbage collection.

The data reported for the runtime event metrics (e.g. mallocs, frees, gcs, and cgo calls,) are the counts since the last time metrics were collected, divided by the time since the last time the metric was collected, to produce a rate, which is calculated using integer division.

For the best results, collect these messages on a regular interval.

func CollectGoStatsTotals 

func CollectGoStatsTotals() Composer

CollectGoStatsTotals constructs a Composer, which is a GoRuntimeInfo internally, that contains data collected from the Go runtime about the state of memory use and garbage collection.

The data reported for the runtime event metrics (e.g. mallocs, frees, gcs, and cgo calls,) are totals collected since the beginning on the runtime.

func CollectProcessInfo 

func CollectProcessInfo(pid int32) Composer

CollectProcessInfo returns a populated ProcessInfo message.Composer instance for the specified pid.

func CollectProcessInfoSelf 

func CollectProcessInfoSelf() Composer

CollectProcessInfoSelf returns a populated ProcessInfo message.Composer for the pid of the current process.

func CollectProcessInfoSelfWithChildren 

func CollectProcessInfoSelfWithChildren() []Composer

CollectProcessInfoSelfWithChildren returns a slice of populated ProcessInfo message.Composer instances for the current process and all children processes.

func CollectProcessInfoWithChildren 

func CollectProcessInfoWithChildren(pid int32) []Composer

CollectProcessInfoWithChildren returns a slice of populated ProcessInfo message.Composer instances for the process with the specified pid and all children processes for that process.

func CollectSystemInfo 

func CollectSystemInfo() Composer

CollectSystemInfo returns a populated SystemInfo object, without a message.

func ConvertToComposer 

func ConvertToComposer(p level.Priority, message interface{}) Composer

ConvertToComposer can coerce unknown objects into Composer instances, as possible. This method will override the priority of composers set to it.

func ConvertToComposerWithLevel 

func ConvertToComposerWithLevel(p level.Priority, message interface{}) Composer

ConvertToComposerWithLevel can coerce unknown objects into Composers, but will only override the priority of Composers.

func MakeComposerProducerMessage 

func MakeComposerProducerMessage(cp ComposerProducer) Composer

MakeComposerMessage constructs a message that will call the ComposerProducer function lazily during logging.

ComposerProducer functions are only called, before calling the Loggable, String, Raw, or Annotate methods. Changing the priority does not call the function. In practice, if the priority of the message is below the logging threshold, then the function will never be called.

func MakeConvertedFieldsProducer 

func MakeConvertedFieldsProducer(mp func() map[string]interface{}) Composer

MakeConvertedFieldsProducer converts a generic map to a fields producer, as the message types are equivalent.

func MakeEmailMessage 

func MakeEmailMessage(e Email) Composer

MakeEmailMessage creates a composer for emails without a priority set

func MakeErrorProducerMessage 

func MakeErrorProducerMessage(ep ErrorProducer) Composer

MakeErrorProducerMessage returns a mesage that wrapps an error producing function. If the function returns then there is never a message logged.

ErrorProducer functions are only called, before calling the Loggable, String, Raw, or Annotate methods. Changing the priority does not call the function. In practice, if the priority of the message is below the logging threshold, then the function will never be called.

func MakeFields 

func MakeFields(f Fields) Composer

MakeFields creates a composer interface from *just* a Fields instance.

func MakeFieldsMessage 

func MakeFieldsMessage(message string, f Fields) Composer

MakeFieldsMessage constructs a fields Composer from a message string and Fields object, without specifying the priority of the message.

func MakeFieldsProducerMessage 

func MakeFieldsProducerMessage(fp FieldsProducer) Composer

MakeFieldsProducerMessage constructs a lazy FieldsProducer wrapping message at the specified level.

FieldsProducer functions are only called, before calling the Loggable, String, Raw, or Annotate methods. Changing the priority does not call the function. In practice, if the priority of the message is below the logging threshold, then the function will never be called.

func MakeGoStatsDeltas 

func MakeGoStatsDeltas(msg string) Composer

MakeGoStatsDeltas has the same semantics as CollectGoStatsDeltas, but additionally allows you to set a message string to annotate the data.

func MakeGoStatsRates 

func MakeGoStatsRates(msg string) Composer

MakeGoStatsRates has the same semantics as CollectGoStatsRates, but additionally allows you to set a message string to annotate the data.

func MakeGoStatsTotals 

func MakeGoStatsTotals(msg string) Composer

MakeGoStatsTotals has the same semantics as CollectGoStatsTotals, but additionally allows you to set a message string to annotate the data.

func MakeGroupComposer 

func MakeGroupComposer(msgs ...Composer) Composer

MakeGroupComposer provides a variadic interface for creating a GroupComposer.

func MakeSimpleFields 

func MakeSimpleFields(f Fields) Composer

MakeSimpleFields returns a structured Composer that does not attach basic logging metadata.

func MakeSimpleFieldsMessage 

func MakeSimpleFieldsMessage(msg string, f Fields) Composer

MakeSimpleFieldsMessage returns a structured Composer that does not attach basic logging metadata, but allows callers to specify the message (the "message" field) as a string.

func MakeSlackMessage 

func MakeSlackMessage(target string, msg string, attachments []SlackAttachment) Composer

MakeSlackMessage creates a composer for message to slack without a priority

func MakeSystemInfo 

func MakeSystemInfo(message string) Composer

MakeSystemInfo builds a populated SystemInfo object with the specified message.

func NewBytes 

func NewBytes(b []byte) Composer

NewBytes provides a basic message consisting of a single line.

func NewBytesMessage 

func NewBytesMessage(p level.Priority, b []byte) Composer

NewBytesMessage provides a Composer interface around a byte slice, which are always logable unless the string is empty.

func NewComposerProducerMessage 

func NewComposerProducerMessage(p level.Priority, cp ComposerProducer) Composer

NewComposerMessage constructs a message, with the given priority, that will call the ComposerProducer function lazily during logging.

ComposerProducer functions are only called, before calling the Loggable, String, Raw, or Annotate methods. Changing the priority does not call the function. In practice, if the priority of the message is below the logging threshold, then the function will never be called.

func NewConvertedFieldsProducer 

func NewConvertedFieldsProducer(p level.Priority, mp func() map[string]interface{}) Composer

NewConvertedFieldsProducer converts a generic map to a fields producer at the specified priority, as the message types are equivalent,

func NewDefaultMessage 

func NewDefaultMessage(p level.Priority, message string) Composer

NewDefaultMessage provides a Composer interface around a single string, which are always logable unless the string is empty.

func NewEmailMessage 

func NewEmailMessage(l level.Priority, e Email) Composer

NewEmailMessage returns a composer for emails

func NewError 

func NewError(err error) Composer

NewError returns an error composer, like NewErrorMessage, but without the requirement to specify priority, which you may wish to specify directly.

func NewErrorMessage 

func NewErrorMessage(p level.Priority, err error) Composer

NewErrorMessage takes an error object and returns a Composer instance that only renders a loggable message when the error is non-nil.

These composers also implement the error interface and the pkg/errors.Causer interface and so can be passed as errors and used with existing error-wrapping mechanisms.

func NewErrorProducerMessage 

func NewErrorProducerMessage(p level.Priority, ep ErrorProducer) Composer

NewErrorProducerMessage returns a mesage that wrapps an error producing function, at the specified level. If the function returns then there is never a message logged.

ErrorProducer functions are only called, before calling the Loggable, String, Raw, or Annotate methods. Changing the priority does not call the function. In practice, if the priority of the message is below the logging threshold, then the function will never be called.

func NewErrorWrap 

func NewErrorWrap(err error, base string, args ...interface{}) Composer

NewErrorWrap produces a message.Composer that combines the functionality of an Error composer that renders a loggable error message for non-nil errors with a normal formatted message (e.g. fmt.Sprintf). These messages only log if the error is non-nil.

func NewErrorWrapMessage 

func NewErrorWrapMessage(p level.Priority, err error, base string, args ...interface{}) Composer

NewErrorWrapMessage produces a fully configured message.Composer that combines the functionality of an Error composer that renders a loggable error message for non-nil errors with a normal formatted message (e.g. fmt.Sprintf). These messages only log if the error is non-nil.

func NewErrorWrappedComposer 

func NewErrorWrappedComposer(err error, m Composer) Composer

NewErrorWrappedComposer provvides a way to construct a log message that annotates an error.

func NewFields 

func NewFields(p level.Priority, f Fields) Composer

NewFields constructs a full configured fields Composer.

func NewFieldsMessage 

func NewFieldsMessage(p level.Priority, message string, f Fields) Composer

NewFieldsMessage creates a fully configured Composer instance that will attach some additional structured data. This constructor allows you to include a string message as well as Fields object.

func NewFieldsProducerMessage 

func NewFieldsProducerMessage(p level.Priority, fp FieldsProducer) Composer

NewFieldsProducerMessage constructs a lazy FieldsProducer wrapping message at the specified level.

FieldsProducer functions are only called, before calling the Loggable, String, Raw, or Annotate methods. Changing the priority does not call the function. In practice, if the priority of the message is below the logging threshold, then the function will never be called.

func NewFormatted 

func NewFormatted(base string, args ...interface{}) Composer

NewFormatted returns a message.Composer roughly equivalent to an fmt.Sprintf().

func NewFormattedMessage 

func NewFormattedMessage(p level.Priority, base string, args ...interface{}) Composer

NewFormattedMessage takes arguments as fmt.Sprintf(), and returns an object that only runs the format operation as part of the String() method.

func NewGoStatsDeltas 

func NewGoStatsDeltas(p level.Priority, msg string) Composer

NewGoStatsDeltas has the same semantics as CollectGoStatsDeltas, but additionally allows you to set a message string to annotate the data.

func NewGoStatsRates 

func NewGoStatsRates(p level.Priority, msg string) Composer

NewGoStatsRates has the same semantics as CollectGoStatsRates, but additionally allows you to set a message string to annotate the data.

func NewGoStatsTotals 

func NewGoStatsTotals(p level.Priority, msg string) Composer

NewGoStatsTotals has the same semantics as CollectGoStatsTotals, but additionally allows you to set a message string and log level to annotate the data.

func NewGroupComposer 

func NewGroupComposer(msgs []Composer) Composer

NewGroupComposer returns a GroupComposer object from a slice of Composers.

func NewGroupComposerWithPriority 

func NewGroupComposerWithPriority(p level.Priority, msgs []Composer) Composer

NewGroupComposerWithPriority constructs a group composer from a collection of composers.

func NewLine 

func NewLine(args ...interface{}) Composer

NewLine returns a message Composer roughly equivalent to fmt.Sprintln().

func NewLineMessage 

func NewLineMessage(p level.Priority, args ...interface{}) Composer

NewLineMessage is a basic constructor for a type that, given a bunch of arguments, calls fmt.Sprintln() on the arguments passed to the constructor during the String() operation. Use in combination with Compose[*] logging methods.

func NewProcessInfo 

func NewProcessInfo(priority level.Priority, pid int32, message string) Composer

NewProcessInfo constructs a fully configured and populated Processinfo message.Composer instance for the specified process.

func NewSimpleBytes 

func NewSimpleBytes(b []byte) Composer

NewSimpleBytes produces a bytes-wrapping message but does not collect metadata.

func NewSimpleBytesMessage 

func NewSimpleBytesMessage(p level.Priority, b []byte) Composer

NewSimpleBytesMessage produces a bytes-wrapping message with the specified priority but does not collect metadata.

func NewSimpleFields 

func NewSimpleFields(p level.Priority, f Fields) Composer

NewSimpleFields returns a structured Composer that does not attach basic logging metadata and allows callers to configure the messages' log level.

func NewSimpleFieldsMessage 

func NewSimpleFieldsMessage(p level.Priority, msg string, f Fields) Composer

NewSimpleFieldsMessage returns a structured Composer that does not attach basic logging metadata, but allows callers to specify the message (the "message" field) as well as the message's log-level.

func NewSimpleString 

func NewSimpleString(m string) Composer

NewSimpleString produces a string message that does not attach process metadata.

func NewSimpleStringMessage 

func NewSimpleStringMessage(p level.Priority, message string) Composer

NewSimpleStringMessage produces a string message with a priority that does not attach process metadata.

func NewSlackMessage 

func NewSlackMessage(p level.Priority, target string, msg string, attachments []SlackAttachment) Composer

NewSlackMessage creates a composer for messages to slack

func NewStack 

func NewStack(skip int, message string) Composer

NewStack builds a Composer implementation that captures the current stack trace with a single string message. Use the skip argument to skip frames if your embedding this in your own wrapper or wrappers.

func NewStackFormatted 

func NewStackFormatted(skip int, message string, args ...interface{}) Composer

NewStackFormatted returns a composer that builds a fmt.Printf style message that also captures a stack trace. Use the skip argument to skip frames if your embedding this in your own wrapper or wrappers.

func NewStackLines 

func NewStackLines(skip int, messages ...interface{}) Composer

NewStackLines returns a composer that builds a fmt.Println style message that also captures a stack trace. Use the skip argument to skip frames if your embedding this in your own wrapper or wrappers.

func NewString 

func NewString(m string) Composer

NewString provides a basic message consisting of a single line.

func NewSystemInfo 

func NewSystemInfo(priority level.Priority, message string) Composer

NewSystemInfo returns a fully configured and populated SystemInfo object.

func When 

func When(cond bool, m interface{}) Composer

When returns a conditional message that is only logged if the condition is bool. Converts the second argument to a composer, if needed, using the same rules that the logging methods use.

func WhenMsg 

func WhenMsg(cond bool, m string) Composer

WhenMsg returns a conditional message that is only logged if the condition is bool, and creates a string message that will only log when the message content is not the empty string. Use this for a more strongly-typed conditional logging message.

func Whenf 

func Whenf(cond bool, m string, args ...interface{}) Composer

Whenf returns a conditional message that is only logged if the condition is bool, and creates a sprintf-style message, which will itself only log if the base expression is not the empty string.

func Whenln 

func Whenln(cond bool, args ...interface{}) Composer

Whenln returns a conditional message that is only logged if the condition is bool, and creates a sprintf-style message, which will itself only log if the base expression is not the empty string.

func WrapError 

func WrapError(err error, m interface{}) Composer

WrapError wraps an error and creates a composer converting the argument into a composer in the same manner as the front end logging methods.

func WrapErrorFunc 

func WrapErrorFunc(ep ErrorProducer, m interface{}) Composer

WrapErrorFunc produces a lazily-composed wrapped error message. The function is only called is

The resulting method itself implements the "error" interface (supporing unwrapping,) as well as the composer type, so you can return the result of this function as an error to avoid needing to manage multiple error annotations.

func WrapErrorf 

func WrapErrorf(err error, msg string, args ...interface{}) Composer

WrapErrorf wraps an error and creates a composer using a Sprintf-style formated composer.

func WrapStack 

func WrapStack(skip int, msg interface{}) Composer

WrapStack annotates a message, converted to a composer using the normal rules if needed, with a stack trace. Use the skip argument to skip frames if your embedding this in your own wrapper or wrappers.

type ComposerProducer 

type ComposerProducer func() Composer

ComposerProducer constructs a lazy composer, and makes it easy to implement new Composers as functions returning an existing composer type. Consider the following: 

grip.Info(func() message.Composer { return WrapError(validateRequest(req), message.Fields{"op": "name"})})

Grip can automatically convert these functions when passed to a logging function.

If the Fields object is nil or empty then no message is ever logged.

type Email 

type Email struct {
	From       string   `bson:"from" json:"from" yaml:"from"`
	Recipients []string `bson:"recipients" json:"recipients" yaml:"recipients"`
	Subject    string   `bson:"subject" json:"subject" yaml:"subject"`
	Body       string   `bson:"body" json:"body" yaml:"body"`
	// PlainTextContents dictates the Content-Type of the email. If true,
	// it will text/plain; otherwise, it is text/html. This value is overridden
	// by the presence of a "Content-Type" header in Headers.
	PlainTextContents bool `bson:"is_plain_text" json:"is_plain_text" yaml:"is_plain_text"`

	// Headers adds additional headers to the email body, ignoring any
	// named "To", "From", "Subject", or "Content-Transfer-Encoding"
	// (which should be set with the above fields)
	Headers map[string][]string `bson:"headers" json:"headers" yaml:"headers"`
}

Email represents the parameters of an email message

type ErrorProducer 

type ErrorProducer func() error

ErrorProducer is a function that returns an error, and is used for constructing message that lazily wraps the resulting function which is called when the message is dispatched.

If you pass one of these functions to a logging method, the ConvertToComposer operation will construct a lazy Composer based on this function, as in: 

grip.Error(func() error { return errors.New("error message") })

It may be useful also to pass a "closer" function in this form, as in: 

grip.Error(file.Close)

As a special case the WrapErrorFunc method has the same semantics as other ErrorProducer methods, but makes it possible to annotate an error.

type Fields 

type Fields map[string]interface{}

Fields is a convince type that wraps map[string]interface{} and is used for attaching structured metadata to a build request. For example: 

message.Fields{"key0", <value>, "key1", <value>}

type FieldsProducer 

type FieldsProducer func() Fields

FieldsProducer is a function that returns a structured message body as a way of writing simple Composer implementations in the form anonymous functions, as in: 

grip.Info(func() message.Fields {return message.Fields{"message": "hello world!"}})

Grip can automatically convert these functions when passed to a logging function.

If the Fields object is nil or empty then no message is logged.

type GoRuntimeInfo 

type GoRuntimeInfo struct {
	HeapObjects uint64        `bson:"memory.objects.heap" json:"memory.objects.heap" yaml:"memory.objects.heap"`
	Alloc       uint64        `bson:"memory.summary.alloc" json:"memory.summary.alloc" yaml:"memory.summary.alloc"`
	HeapSystem  uint64        `bson:"memory.summary.system" json:"memory.summary.system" yaml:"memory.summary.system"`
	HeapIdle    uint64        `bson:"memory.heap.idle" json:"memory.heap.idle" yaml:"memory.heap.idle"`
	HeapInUse   uint64        `bson:"memory.heap.used" json:"memory.heap.used" yaml:"memory.heap.used"`
	Mallocs     int64         `bson:"memory.counters.mallocs" json:"memory.counters.mallocs" yaml:"memory.counters.mallocs"`
	Frees       int64         `bson:"memory.counters.frees" json:"memory.counters.frees" yaml:"memory.counters.frees"`
	GC          int64         `bson:"gc.rate" json:"gc.rate" yaml:"gc.rate"`
	GCPause     time.Duration `bson:"gc.pause.duration.last" json:"gc.pause.last" yaml:"gc.pause.last"`
	GCLatency   time.Duration `bson:"gc.pause.duration.latency" json:"gc.pause.duration.latency" yaml:"gc.pause.duration.latency"`
	Goroutines  int64         `bson:"goroutines.total" json:"goroutines.total" yaml:"goroutines.total"`
	CgoCalls    int64         `bson:"cgo.calls" json:"cgo.calls" yaml:"cgo.calls"`

	Message string `bson:"message" json:"message" yaml:"message"`
	Base    `json:"metadata,omitempty" bson:"metadata,omitempty" yaml:"metadata,omitempty"`
	// contains filtered or unexported fields
}

GoRuntimeInfo provides

func (*GoRuntimeInfo) Loggable 

func (s *GoRuntimeInfo) Loggable() bool

Loggable returns true when the GoRuntimeInfo structure is populated. Loggable is part of the Composer interface.

func (*GoRuntimeInfo) Raw 

func (s *GoRuntimeInfo) Raw() interface{}

Raw is part of the Composer interface and returns the GoRuntimeInfo object itself.

func (*GoRuntimeInfo) String 

func (s *GoRuntimeInfo) String() string

type GroupComposer 

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

GroupComposer handles groups of composers as a single message, joining messages with a new line for the string format and returning a slice of interfaces for the Raw() form.

Unlike most composer types, the GroupComposer is exported, and provides the additional Messages() method to access the composer objects as a slice.

func (*GroupComposer) Add 

func (g *GroupComposer) Add(msg Composer)

Add supports adding messages to an existing group composer.

func (*GroupComposer) Annotate 

func (g *GroupComposer) Annotate(k string, v interface{}) error

Annotate calls the Annotate method of every non-nil component Composer.

func (*GroupComposer) Append 

func (g *GroupComposer) Append(msgs ...Composer)

Append provides a variadic alternative to the Extend method.

func (*GroupComposer) Extend 

func (g *GroupComposer) Extend(msg []Composer)

Extend makes it possible to add a group of messages to an existing group composer.

func (*GroupComposer) Loggable 

func (g *GroupComposer) Loggable() bool

Loggable returns true if at least one of the constituent Composers is loggable.

func (*GroupComposer) Messages 

func (g *GroupComposer) Messages() []Composer

Messages returns a the underlying collection of messages.

func (*GroupComposer) Priority 

func (g *GroupComposer) Priority() level.Priority

Priority returns the highest priority of the constituent Composers.

func (*GroupComposer) Raw 

func (g *GroupComposer) Raw() interface{}

Raw returns a slice of interfaces containing the raw form of all the constituent composers.

func (*GroupComposer) SetPriority 

func (g *GroupComposer) SetPriority(l level.Priority) error

SetPriority sets the priority of all constituent Composers *only* if the existing level is unset, and does not propagate an error, but will *not* unset the level of the compser and will return an error in this case.

func (*GroupComposer) String 

func (g *GroupComposer) String() string

String satisfies the fmt.Stringer interface, and returns a string of the string form of all constituent composers joined with a newline.

type ProcessInfo 

type ProcessInfo struct {
	Message        string                   `json:"message" bson:"message"`
	Pid            int32                    `json:"pid" bson:"pid"`
	Parent         int32                    `json:"parentPid" bson:"parentPid"`
	Threads        int                      `json:"numThreads" bson:"numThreads"`
	Command        string                   `json:"command" bson:"command"`
	CPU            StatCPUTimes             `json:"cpu" bson:"cpu"`
	IoStat         process.IOCountersStat   `json:"io" bson:"io"`
	NetStat        []net.IOCountersStat     `json:"net" bson:"net"`
	Memory         process.MemoryInfoStat   `json:"mem" bson:"mem"`
	MemoryPlatform process.MemoryInfoExStat `json:"memExtra" bson:"memExtra"`
	Errors         []string                 `json:"errors" bson:"errors"`
	Base           `json:"metadata,omitempty" bson:"metadata,omitempty"`
	// contains filtered or unexported fields
}

ProcessInfo holds the data for per-process statistics (e.g. cpu, memory, io). The Process info composers produce messages in this form.

func (*ProcessInfo) Loggable 

func (p *ProcessInfo) Loggable() bool

Loggable returns true when the Processinfo structure has been populated.

func (*ProcessInfo) Raw 

func (p *ProcessInfo) Raw() interface{}

Raw always returns the ProcessInfo object, however it will call the Collect method of the base operation first.

func (*ProcessInfo) String 

func (p *ProcessInfo) String() string

String returns a string representation of the message, lazily rendering the message, and caching it privately.

type Slack 

type Slack struct {
	Target      string              `bson:"target" json:"target" yaml:"target"`
	Msg         string              `bson:"msg" json:"msg" yaml:"msg"`
	Attachments []*slack.Attachment `bson:"attachments" json:"attachments" yaml:"attachments"`
}

Slack is a message to a Slack channel or user

type SlackAttachment 

type SlackAttachment struct {
	Color    string `bson:"color,omitempty" json:"color,omitempty" yaml:"color,omitempty"`
	Fallback string `bson:"fallback" json:"fallback" yaml:"fallback"`

	AuthorName string `bson:"author_name,omitempty" json:"author_name,omitempty" yaml:"author_name,omitempty"`
	AuthorIcon string `bson:"author_icon,omitempty" json:"author_icon,omitempty" yaml:"author_icon,omitempty"`

	Title     string `bson:"title,omitempty" json:"title,omitempty" yaml:"title,omitempty"`
	TitleLink string `bson:"title_link,omitempty" json:"title_link,omitempty" yaml:"title_link,omitempty"`
	Text      string `bson:"text" json:"text" yaml:"text"`

	Fields     []*SlackAttachmentField `bson:"fields,omitempty" json:"fields,omitempty" yaml:"fields,omitempty"`
	MarkdownIn []string                `bson:"mrkdwn_in,omitempty" json:"mrkdwn_in,omitempty" yaml:"mrkdwn_in,omitempty"`

	Footer string `bson:"footer,omitempty" json:"footer,omitempty" yaml:"footer,omitempty"`
}

SlackAttachment is a single attachment to a slack message. This type is the same as bluele/slack.Attachment

type SlackAttachmentField 

type SlackAttachmentField struct {
	Title string `bson:"title" json:"title" yaml:"title"`
	Value string `bson:"value" json:"value" yaml:"value"`
	Short bool   `bson:"short" json:"short" yaml:"short"`
}

SlackAttachmentField is one of the optional fields that can be attached to a slack message. This type is the same as bluele/slack.AttachmentField

type StackFrame 

type StackFrame struct {
	Function string `bson:"function" json:"function" yaml:"function"`
	File     string `bson:"file" json:"file" yaml:"file"`
	Line     int    `bson:"line" json:"line" yaml:"line"`
}

StackFrame captures a single item in a stack trace, and is used internally and in the StackTrace output.

func (StackFrame) String 

func (f StackFrame) String() string

type StackFrames 

type StackFrames []StackFrame

StackFrames makes slices of stack traces printable.

func (StackFrames) String 

func (f StackFrames) String() string

type StackTrace 

type StackTrace struct {
	Context interface{} `bson:"context,omitempty" json:"context,omitempty" yaml:"context,omitempty"`
	Frames  StackFrames `bson:"frames" json:"frames" yaml:"frames"`
}

StackTrace structs are returned by the Raw method of the stackMessage type

func (StackTrace) String 

func (s StackTrace) String() string

type StatCPUTimes 

type StatCPUTimes struct {
	User      int64 `json:"user" bson:"user"`
	System    int64 `json:"system" bson:"system"`
	Idle      int64 `json:"idle" bson:"idle"`
	Nice      int64 `json:"nice" bson:"nice"`
	Iowait    int64 `json:"iowait" bson:"iowait"`
	Irq       int64 `json:"irq" bson:"irq"`
	Softirq   int64 `json:"softirq" bson:"softirq"`
	Steal     int64 `json:"steal" bson:"steal"`
	Guest     int64 `json:"guest" bson:"guest"`
	GuestNice int64 `json:"guestNice" bson:"guestNice"`
}

StatCPUTimes provides a mirror of gopsutil/cpu.TimesStat with integers rather than floats.

type SystemInfo 

type SystemInfo struct {
	Message    string                `json:"message" bson:"message"`
	CPU        StatCPUTimes          `json:"cpu" bson:"cpu"`
	CPUPercent float64               `json:"cpu_percent" bson:"cpu_percent"`
	NumCPU     int                   `json:"num_cpus" bson:"num_cpus"`
	VMStat     mem.VirtualMemoryStat `json:"vmstat" bson:"vmstat"`
	NetStat    net.IOCountersStat    `json:"netstat" bson:"netstat"`
	Partitions []disk.PartitionStat  `json:"partitions" bson:"partitions"`
	Usage      []disk.UsageStat      `json:"usage" bson:"usage"`
	IOStat     []disk.IOCountersStat `json:"iostat" bson:"iostat"`
	Errors     []string              `json:"errors" bson:"errors"`
	Base       `json:"metadata,omitempty" bson:"metadata,omitempty�"`
	// contains filtered or unexported fields
}

SystemInfo is a type that implements message.Composer but also collects system-wide resource utilization statistics about memory, CPU, and network use, along with an optional message.

func (*SystemInfo) Loggable 

func (s *SystemInfo) Loggable() bool

Loggable returns true when the Processinfo structure has been populated.

func (*SystemInfo) Raw 

func (s *SystemInfo) Raw() interface{}

Raw always returns the SystemInfo object.

func (*SystemInfo) String 

func (s *SystemInfo) String() string

String returns a string representation of the message, lazily rendering the message, and caching it privately.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.