log

package
v1.1.9 Latest Latest
Warning

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

 Go to latest Published: Oct 1, 2018 License: Apache-2.0 Imports: 39 Imported by: 0

Documentation

Overview

Package log implements logging analogous to the Google-internal C++ INFO/ERROR/V setup. It provides functions Info, Warning, Error, Fatal, plus formatting variants such as Infof. It also provides V-style logging and adaptions for use as a structured logging engine.

Basic examples: 

	log.Info("Prepare to repel boarders")

	log.Fatal("Initialization failed", err)

 // Log with context.
 log.Infoc(context, "client error: %s", err)

See the documentation for the V function for an explanation of these examples: 

if log.V(2) {
	log.Info("Starting transaction...")
}

Log output is buffered and written periodically using Flush. Programs should call Flush before exiting to guarantee all log output is written.

By default, all log statements write to files in a temporary directory. This package provides several flags that modify this behavior. These are provided via the pflags library; see InitFlags. 

	--logtostderr=LEVEL
		Logs are written to standard error as well as to files.
   Entries with severity below LEVEL are not written to stderr.
   "true" and "false" are also supported (everything / nothing).
	--log-dir="..."
		Log files will be written to this directory instead of the
		default target directory.
 --log-file-verbosity=LEVEL
   Entries with severity below LEVEL are not written to the log file.
   "true" and "false" are also supported (everything / nothing).
 --log-file-max-size=N
   Log files are rotated after reaching that size.
 --log-dir-max-size=N
   Log files are removed after log directory reaches that size.

	Other flags provide aids to debugging.

	--log-backtrace-at=""
		When set to a file and line number holding a logging statement,
		such as
			-log_backtrace_at=gopherflakes.go:234
		a stack trace will be written to the Info log whenever execution
		hits that statement. (Unlike with --vmodule, the ".go" must be
		present.)
	--verbosity=0
		Enable V-leveled logging at the specified level.
	--vmodule=""
		The syntax of the argument is a comma-separated list of pattern=N,
		where pattern is a literal file name (minus the ".go" suffix) or
		"glob" pattern and N is a V level. For instance,
			-vmodule=gopher*=3
		sets the V level to 3 in all Go files whose names begin "gopher".

	Package log is a generated protocol buffer package.

	It is generated from these files:
		cockroach/pkg/util/log/log.proto

	It has these top-level messages:
		Entry
		FileDetails
		FileInfo

Index

Constants

This section is empty.

Variables

View Source 
var (
	// DiagnosticsReportingEnabled wraps "diagnostics.reporting.enabled".
	//
	// "diagnostics.reporting.enabled" enables reporting of metrics related to a
	// node's storage (number, size and health of ranges) back to CockroachDB.
	// Collecting this data from production clusters helps us understand and improve
	// how our storage systems behave in real-world use cases.
	//
	// Note: while the setting itself is actually defined with a default value of
	// `false`, it is usually automatically set to `true` when a cluster is created
	// (or is migrated from a earlier beta version). This can be prevented with the
	// env var COCKROACH_SKIP_ENABLING_DIAGNOSTIC_REPORTING.
	//
	// Doing this, rather than just using a default of `true`, means that a node
	// will not errantly send a report using a default before loading settings.
	DiagnosticsReportingEnabled = settings.RegisterBoolSetting(
		"diagnostics.reporting.enabled",
		"enable reporting diagnostic metrics to cockroach labs",
		false,
	)

	// CrashReports wraps "diagnostics.reporting.send_crash_reports".
	CrashReports = settings.RegisterBoolSetting(
		"diagnostics.reporting.send_crash_reports",
		"send crash and panic reports",
		true,
	)
)
View Source 
var (
	ErrInvalidLengthLog = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLog   = fmt.Errorf("proto: integer overflow")
)
View Source 
var LogFileMaxSize int64 = 10 << 20 // 10MiB

LogFileMaxSize is the maximum size of a log file in bytes.

View Source 
var LogFilesCombinedMaxSize = LogFileMaxSize * 10 // 100MiB

LogFilesCombinedMaxSize is the maximum total size in bytes for log files. Note that this is only checked when log files are created, so the total size of log files per severity might temporarily be up to LogFileMaxSize larger.

View Source 
var OrigStderr = func() *os.File {
	fd, err := dupFD(os.Stderr.Fd())
	if err != nil {
		panic(err)
	}

	return os.NewFile(fd, os.Stderr.Name())
}()

OrigStderr points to the original stderr stream.

View Source 
var Severity_name = map[int32]string{
	0: "UNKNOWN",
	1: "INFO",
	2: "WARNING",
	3: "ERROR",
	4: "FATAL",
	5: "NONE",
	6: "DEFAULT",
}
View Source 
var Severity_value = map[string]int32{
	"UNKNOWN": 0,
	"INFO":    1,
	"WARNING": 2,
	"ERROR":   3,
	"FATAL":   4,
	"NONE":    5,
	"DEFAULT": 6,
}

Functions

func DirSet 

func DirSet() bool

DirSet returns true of the log directory has been changed from its default.

func DisableTracebacks added in v1.1.0 

func DisableTracebacks() func()

DisableTracebacks turns off tracebacks for log.Fatals. Returns a function that sets the traceback settings back to where they were. Only intended for use by tests.

func ErrEvent 

func ErrEvent(ctx context.Context, msg string)

ErrEvent looks for an opentracing.Trace in the context and logs the given message to it. If no Trace is found, it looks for an EventLog in the context and logs the message to it (as an error). If neither is found, does nothing.

func ErrEventf 

func ErrEventf(ctx context.Context, format string, args ...interface{})

ErrEventf looks for an opentracing.Trace in the context and formats and logs the given message to it. If no Trace is found, it looks for an EventLog in the context and formats and logs the message to it (as an error). If neither is found, does nothing.

func Error 

func Error(ctx context.Context, args ...interface{})

Error logs to the ERROR, WARNING, and INFO logs. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Print; a newline is appended.

func Errorf 

func Errorf(ctx context.Context, format string, args ...interface{})

Errorf logs to the ERROR, WARNING, and INFO logs. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func ErrorfDepth 

func ErrorfDepth(ctx context.Context, depth int, format string, args ...interface{})

ErrorfDepth logs to the ERROR, WARNING, and INFO logs, offsetting the caller's stack frame by 'depth'. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func Event 

func Event(ctx context.Context, msg string)

Event looks for an opentracing.Trace in the context and logs the given message to it. If no Trace is found, it looks for an EventLog in the context and logs the message to it. If neither is found, does nothing.

func Eventf 

func Eventf(ctx context.Context, format string, args ...interface{})

Eventf looks for an opentracing.Trace in the context and formats and logs the given message to it. If no Trace is found, it looks for an EventLog in the context and logs the message to it. If neither is found, does nothing.

func Fatal 

func Fatal(ctx context.Context, args ...interface{})

Fatal logs to the INFO, WARNING, ERROR, and FATAL logs, including a stack trace of all running goroutines, then calls os.Exit(255). It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Print; a newline is appended.

func FatalOnPanic 

func FatalOnPanic()

FatalOnPanic recovers from a panic and exits the process with a Fatal log. This is useful for avoiding a panic being caught through a CGo exported function or preventing HTTP handlers from recovering panics and ignoring them.

func Fatalf 

func Fatalf(ctx context.Context, format string, args ...interface{})

Fatalf logs to the INFO, WARNING, ERROR, and FATAL logs, including a stack trace of all running goroutines, then calls os.Exit(255). It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func FatalfDepth 

func FatalfDepth(ctx context.Context, depth int, format string, args ...interface{})

FatalfDepth logs to the INFO, WARNING, ERROR, and FATAL logs (offsetting the caller's stack frame by 'depth'), including a stack trace of all running goroutines, then calls os.Exit(255). It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func FinishEventLog 

func FinishEventLog(ctx context.Context)

FinishEventLog closes the event log in the context (see WithEventLog). Concurrent and subsequent calls to record events are allowed.

func Flush 

func Flush()

Flush flushes all pending log I/O.

func GetLogReader 

func GetLogReader(filename string, restricted bool) (io.ReadCloser, error)

GetLogReader returns a reader for the specified filename. In restricted mode, the filename must be the base name of a file in this process's log directory (this is safe for cases when the filename comes from external sources, such as the admin UI via HTTP). In unrestricted mode any path is allowed, relative to the current directory, with the added feature that simple (base name) file names will be searched in this process's log directory if not found in the current directory.

func HasSpanOrEvent 

func HasSpanOrEvent(ctx context.Context) bool

HasSpanOrEvent returns true if the context has a span or event that should be logged to.

func Info 

func Info(ctx context.Context, args ...interface{})

Info logs to the INFO log. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Print; a newline is appended.

func Infof 

func Infof(ctx context.Context, format string, args ...interface{})

Infof logs to the INFO log. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func InfofDepth 

func InfofDepth(ctx context.Context, depth int, format string, args ...interface{})

InfofDepth logs to the INFO log, offsetting the caller's stack frame by 'depth'. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func Intercept added in v1.1.0 

func Intercept(ctx context.Context, f InterceptorFn)

Intercept diverts log traffic to the given function `f`. When `f` is not nil, the logging package begins operating at full verbosity (i.e. `V(n) == true` for all `n`) but nothing will be printed to the logs. Instead, `f` is invoked for each log entry.

To end log interception, invoke `Intercept()` with `f == nil`. Note that interception does not terminate atomically, that is, the originally supplied callback may still be invoked after a call to `Intercept` with `f == nil`.

func LoggingToStderr 

func LoggingToStderr(s Severity) bool

LoggingToStderr returns true if log messages of the given severity are visible on stderr.

func MakeMessage 

func MakeMessage(ctx context.Context, format string, args []interface{}) string

MakeMessage creates a structured log entry.

func NewStdLogger 

func NewStdLogger(severity Severity) *stdLog.Logger

NewStdLogger creates a *stdLog.Logger that forwards messages to the CockroachDB logs with the specified severity.

func RecoverAndReportPanic 

func RecoverAndReportPanic(ctx context.Context, sv *settings.Values)

RecoverAndReportPanic can be invoked on goroutines that run with stderr redirected to logs to ensure the user gets informed on the real stderr a panic has occurred.

func ReportPanic 

func ReportPanic(ctx context.Context, sv *settings.Values, r interface{}, depth int)

ReportPanic reports a panic has occurred on the real stderr.

func SendCrashReport added in v1.1.2 

func SendCrashReport(
	ctx context.Context, sv *settings.Values, depth int, format string, reportables []interface{},
)

SendCrashReport posts to sentry. The `reportables` is essentially the `args...` in `log.Fatalf(format, args...)` (similarly for `log.Fatal`) or `[]interface{}{arg}` in `panic(arg)`.

The format string and those items in `reportables` which are a) an error or b) (values of or pointers to) `log.Safe` will be used verbatim to construct the error that is reported to sentry.

TODO(dt,knz,sql-team): we need to audit all sprintf'ing of values into the errors and strings passed to panic, to ensure raw user data is kept separate and can thus be elided here. For now, the type is about all we can assume is safe to report, which combined with file and line info should be at least somewhat helpful in telling us where crashes are coming from. We capture the full stacktrace below, so we only need the short file and line here help uniquely identify the error. Some exceptions, like a runtime.Error, are assumed to be fine as-is.

func SetExitFunc 

func SetExitFunc(f func(int))

SetExitFunc allows setting a function that will be called to exit the process when a Fatal message is generated.

func SetSync 

func SetSync(sync bool)

SetSync configures whether logging synchronizes all writes.

func SetVModule added in v1.1.0 

func SetVModule(value string) error

SetVModule alters the vmodule logging level to the passed in value.

func SetupCrashReporter 

func SetupCrashReporter(ctx context.Context, cmd string)

SetupCrashReporter sets the crash reporter info.

func Shout 

func Shout(ctx context.Context, sev Severity, args ...interface{})

Shout logs to the specified severity's log, and also to the real stderr if logging is currently redirected to a file.

func StartGCDaemon 

func StartGCDaemon()

StartGCDaemon starts the log file GC -- this must be called after command-line parsing has completed so that no data is lost when the user configures larger max sizes than the defaults.

func V 

func V(level level) bool

V returns true if the logging verbosity is set to the specified level or higher.

func VDepth 

func VDepth(level level, depth int) bool

VDepth reports whether verbosity at the call site is at least the requested level.

func VEvent 

func VEvent(ctx context.Context, level level, msg string)

VEvent either logs a message to the log files (which also outputs to the active trace or event log) or to the trace/event log alone, depending on whether the specified verbosity level is active.

func VEventf 

func VEventf(ctx context.Context, level level, format string, args ...interface{})

VEventf either logs a message to the log files (which also outputs to the active trace or event log) or to the trace/event log alone, depending on whether the specified verbosity level is active.

func VEventfDepth added in v1.1.0 

func VEventfDepth(ctx context.Context, depth int, level level, format string, args ...interface{})

VEventfDepth performs the same as VEventf but checks the verbosity level at the given depth in the call stack.

func Warning 

func Warning(ctx context.Context, args ...interface{})

Warning logs to the WARNING and INFO logs. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Print; a newline is appended.

func Warningf 

func Warningf(ctx context.Context, format string, args ...interface{})

Warningf logs to the WARNING and INFO logs. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func WarningfDepth 

func WarningfDepth(ctx context.Context, depth int, format string, args ...interface{})

WarningfDepth logs to the WARNING and INFO logs, offsetting the caller's stack frame by 'depth'. It extracts log tags from the context and logs them along with the given message. Arguments are handled in the manner of fmt.Printf; a newline is appended.

func WithEventLog 

func WithEventLog(ctx context.Context, family, title string) context.Context

WithEventLog creates and embeds a trace.EventLog in the context, causing future logging and event calls to go to the EventLog. The current context must not have an existing open span.

func WithLogTag 

func WithLogTag(ctx context.Context, name string, value interface{}) context.Context

WithLogTag returns a context (derived from the given context) which when used with a logging function results in the given name and value being printed in the message.

The value is stored and passed to fmt.Fprint when the log message is constructed. A fmt.Stringer can be passed which allows the value to be "dynamic".

If the value is nil, just the name shows up.

func WithLogTagInt 

func WithLogTagInt(ctx context.Context, name string, value int) context.Context

WithLogTagInt is a variant of WithLogTag that avoids the allocation associated with boxing the value in an interface{}.

func WithLogTagInt64 

func WithLogTagInt64(ctx context.Context, name string, value int64) context.Context

WithLogTagInt64 is a variant of WithLogTag that avoids the allocation associated with boxing the value in an interface{}.

func WithLogTagStr 

func WithLogTagStr(ctx context.Context, name string, value string) context.Context

WithLogTagStr is a variant of WithLogTag that avoids the allocation associated with boxing the value in an interface{}.

func WithNoEventLog 

func WithNoEventLog(ctx context.Context) context.Context

WithNoEventLog creates a context which no longer has an embedded event log.

Types

type AmbientContext 

type AmbientContext struct {
	// Tracer is used to open spans (see AnnotateCtxWithSpan).
	Tracer opentracing.Tracer
	// contains filtered or unexported fields
}

AmbientContext is a helper type used to "annotate" context.Contexts with log tags and a Tracer or EventLog. It is intended to be embedded into various server components.

Example: 

type SomeServer struct {
  log.AmbientContext
  ...
}

ac := AmbientContext{Tracer: tracing.NewTracer()}
ac.AddLogTag("n", 1)

s := &SomeServer{
  AmbientContext: ac
  ...
}

// on an operation with context ctx
ctx = s.AnnotateCtx(ctx)
...

// run a worker
s.stopper.RunWorker(func() {
  ctx := s.AnnotateCtx(context.Background())
  ...
})

// start a background operation
ctx, span := s.AnnotateCtxWithSpan(context.Background(), "some-op")
defer span.Finish()
...

func (*AmbientContext) AddLogTag 

func (ac *AmbientContext) AddLogTag(name string, value interface{})

AddLogTag adds a tag; see WithLogTag.

func (*AmbientContext) AddLogTagInt 

func (ac *AmbientContext) AddLogTagInt(name string, value int)

AddLogTagInt adds an integer tag; see WithLogTagInt.

func (*AmbientContext) AddLogTagInt64 

func (ac *AmbientContext) AddLogTagInt64(name string, value int64)

AddLogTagInt64 adds an integer tag; see WithLogTagInt64.

func (*AmbientContext) AddLogTagStr 

func (ac *AmbientContext) AddLogTagStr(name string, value string)

AddLogTagStr adds a string tag; see WithLogTagStr.

func (*AmbientContext) AnnotateCtx 

func (ac *AmbientContext) AnnotateCtx(ctx context.Context) context.Context

AnnotateCtx annotates a given context with the information in AmbientContext:

  • the EventLog is embedded in the context if the context doesn't already have an event log or an open trace.
  • the log tags in AmbientContext are added (if ctx doesn't already have them). If the tags already exist, the values from the AmbientContext overwrite the existing values, but the order of the tags might change.

For background operations, context.Background() should be passed; however, in that case it is strongly recommended to open a span if possible (using AnnotateCtxWithSpan).

func (*AmbientContext) AnnotateCtxWithSpan 

func (ac *AmbientContext) AnnotateCtxWithSpan(
	ctx context.Context, opName string,
) (context.Context, opentracing.Span)

AnnotateCtxWithSpan annotates the given context with the information in AmbientContext (see AnnotateCtx) and opens a span.

If the given context has a span, the new span is a child of that span. Otherwise, the Tracer in AmbientContext is used to create a new root span.

The caller is responsible for closing the span (via Span.Finish).

func (*AmbientContext) FinishEventLog 

func (ac *AmbientContext) FinishEventLog()

FinishEventLog closes the event log. Concurrent and subsequent calls to record events from contexts that use this event log embedded are allowed.

func (*AmbientContext) ResetAndAnnotateCtx 

func (ac *AmbientContext) ResetAndAnnotateCtx(ctx context.Context) context.Context

ResetAndAnnotateCtx annotates a given context with the information in AmbientContext, but unlike AnnotateCtx, it drops all log tags in the supplied context before adding the ones from the AmbientContext.

func (*AmbientContext) SetEventLog 

func (ac *AmbientContext) SetEventLog(family, title string)

SetEventLog sets up an event log. Annotated contexts log into this event log (unless there's an open Span).

type Entry 

type Entry struct {
	Severity Severity `protobuf:"varint,1,opt,name=severity,proto3,enum=cockroach.util.log.Severity" json:"severity,omitempty"`
	// Nanoseconds since the epoch.
	Time      int64  `protobuf:"varint,2,opt,name=time,proto3" json:"time,omitempty"`
	Goroutine int64  `protobuf:"varint,6,opt,name=goroutine,proto3" json:"goroutine,omitempty"`
	File      string `protobuf:"bytes,3,opt,name=file,proto3" json:"file,omitempty"`
	Line      int64  `protobuf:"varint,4,opt,name=line,proto3" json:"line,omitempty"`
	Message   string `protobuf:"bytes,5,opt,name=message,proto3" json:"message,omitempty"`
}

Entry represents a cockroach structured log entry.

func FetchEntriesFromFiles 

func FetchEntriesFromFiles(
	startTimestamp, endTimestamp int64, maxEntries int, pattern *regexp.Regexp,
) ([]Entry, error)

FetchEntriesFromFiles fetches all available log entries on disk that are between the 'startTimestamp' and 'endTimestamp'. It will stop reading new files if the number of entries exceeds 'maxEntries'. Log entries are further filtered by the regexp 'pattern' if provided. The logs entries are returned in reverse chronological order.

func MakeEntry added in v1.1.0 

func MakeEntry(s Severity, t int64, file string, line int, msg string) Entry

MakeEntry creates an Entry.

func (*Entry) Descriptor 

func (*Entry) Descriptor() ([]byte, []int)

func (Entry) Format 

func (e Entry) Format(w io.Writer) error

Format writes the log entry to the specified writer.

func (*Entry) Marshal 

func (m *Entry) Marshal() (dAtA []byte, err error)

func (*Entry) MarshalTo 

func (m *Entry) MarshalTo(dAtA []byte) (int, error)

func (*Entry) ProtoMessage 

func (*Entry) ProtoMessage()

func (*Entry) Reset 

func (m *Entry) Reset()

func (*Entry) Size 

func (m *Entry) Size() (n int)

func (*Entry) String 

func (m *Entry) String() string

func (*Entry) Unmarshal 

func (m *Entry) Unmarshal(dAtA []byte) error

type EntryDecoder 

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

EntryDecoder reads successive encoded log entries from the input buffer. Each entry is preceded by a single big-ending uint32 describing the next entry's length.

func NewEntryDecoder 

func NewEntryDecoder(in io.Reader) *EntryDecoder

NewEntryDecoder creates a new instance of EntryDecoder.

func (*EntryDecoder) Decode 

func (d *EntryDecoder) Decode(entry *Entry) error

Decode decodes the next log entry into the provided protobuf message.

type FileDetails 

type FileDetails struct {
	Program  string `protobuf:"bytes,1,opt,name=program,proto3" json:"program,omitempty"`
	Host     string `protobuf:"bytes,2,opt,name=host,proto3" json:"host,omitempty"`
	UserName string `protobuf:"bytes,3,opt,name=user_name,json=userName,proto3" json:"user_name,omitempty"`
	Time     int64  `protobuf:"varint,5,opt,name=time,proto3" json:"time,omitempty"`
	PID      int64  `protobuf:"varint,6,opt,name=pid,proto3" json:"pid,omitempty"`
}

A FileDetails holds all of the particulars that can be parsed by the name of a log file.

func (*FileDetails) Descriptor 

func (*FileDetails) Descriptor() ([]byte, []int)

func (*FileDetails) Marshal 

func (m *FileDetails) Marshal() (dAtA []byte, err error)

func (*FileDetails) MarshalTo 

func (m *FileDetails) MarshalTo(dAtA []byte) (int, error)

func (*FileDetails) ProtoMessage 

func (*FileDetails) ProtoMessage()

func (*FileDetails) Reset 

func (m *FileDetails) Reset()

func (*FileDetails) Size 

func (m *FileDetails) Size() (n int)

func (*FileDetails) String 

func (m *FileDetails) String() string

func (*FileDetails) Unmarshal 

func (m *FileDetails) Unmarshal(dAtA []byte) error

type FileInfo 

type FileInfo struct {
	Name         string      `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	SizeBytes    int64       `protobuf:"varint,2,opt,name=size_bytes,json=sizeBytes,proto3" json:"size_bytes,omitempty"`
	ModTimeNanos int64       `protobuf:"varint,3,opt,name=mod_time_nanos,json=modTimeNanos,proto3" json:"mod_time_nanos,omitempty"`
	Details      FileDetails `protobuf:"bytes,4,opt,name=details" json:"details"`
}

func ListLogFiles 

func ListLogFiles() ([]FileInfo, error)

ListLogFiles returns a slice of FileInfo structs for each log file on the local node, in any of the configured log directories.

func (*FileInfo) Descriptor 

func (*FileInfo) Descriptor() ([]byte, []int)

func (*FileInfo) Marshal 

func (m *FileInfo) Marshal() (dAtA []byte, err error)

func (*FileInfo) MarshalTo 

func (m *FileInfo) MarshalTo(dAtA []byte) (int, error)

func (*FileInfo) ProtoMessage 

func (*FileInfo) ProtoMessage()

func (*FileInfo) Reset 

func (m *FileInfo) Reset()

func (*FileInfo) Size 

func (m *FileInfo) Size() (n int)

func (*FileInfo) String 

func (m *FileInfo) String() string

func (*FileInfo) Unmarshal 

func (m *FileInfo) Unmarshal(dAtA []byte) error

type InterceptorFn added in v1.1.0 

type InterceptorFn func(entry Entry)

InterceptorFn is the type of function accepted by Intercept().

type SafeMessager added in v1.1.3 

type SafeMessager interface {
	SafeMessage() string
}

SafeMessager is implemented by objects which have a way of representing themselves suitably redacted for anonymized reporting.

type SafeType added in v1.1.0 

type SafeType struct {
	V interface{}
}

A SafeType panic can be reported verbatim, i.e. does not leak information. A nil `*SafeType` is not valid for use and may cause panics.

func Safe 

func Safe(v interface{}) SafeType

Safe constructs a SafeType.

func (SafeType) SafeMessage added in v1.1.3 

func (st SafeType) SafeMessage() string

SafeMessage implements SafeMessager.

type Severity 

type Severity int32
const (
	Severity_UNKNOWN Severity = 0
	Severity_INFO    Severity = 1
	Severity_WARNING Severity = 2
	Severity_ERROR   Severity = 3
	Severity_FATAL   Severity = 4
	// NONE is used to specify when no messages
	// should be printed to the log file or stderr.
	Severity_NONE Severity = 5
	// DEFAULT is the end sentinel. It is used during command-line
	// handling to indicate that another value should be replaced instead
	// (depending on which command is being run); see cli/flags.go for
	// details.
	Severity_DEFAULT Severity = 6
)

func SeverityByName 

func SeverityByName(s string) (Severity, bool)

SeverityByName attempts to parse the passed in string into a severity. (i.e. ERROR, INFO). If it succeeds, the returned bool is set to true.

func (Severity) EnumDescriptor 

func (Severity) EnumDescriptor() ([]byte, []int)

func (*Severity) Name 

func (s *Severity) Name() string

Name returns the string representation of the severity (i.e. ERROR, INFO).

func (*Severity) Set 

func (s *Severity) Set(value string) error

Set is part of the flag.Value interface.

func (Severity) String 

func (x Severity) String() string

type TestLogScope 

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

TestLogScope represents the lifetime of a logging output. It ensures that the log files are stored in a directory specific to a test, and asserts that logging output is not written to this directory beyond the lifetime of the scope.

func Scope 

func Scope(t tShim) *TestLogScope

Scope creates a TestLogScope which corresponds to the lifetime of a logging directory. The logging directory is named after the calling test. It also disables logging to stderr for severity levels below ERROR.

func ScopeWithoutShowLogs 

func ScopeWithoutShowLogs(t tShim) *TestLogScope

ScopeWithoutShowLogs ignores the -show-logs flag and should be used for tests that require the logs go to files.

func (*TestLogScope) Close 

func (l *TestLogScope) Close(t tShim)

Close cleans up a TestLogScope. The directory and its contents are deleted, unless the test has failed and the directory is non-empty.

Source Files

View all Source files

Directories

Path Synopsis

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.