logs

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

type LogRecordConfig struct {
	Timestamp            *time.Time
	ObservedTimestamp    time.Time
	TraceId              *trace.TraceID
	SpanId               *trace.SpanID
	TraceFlags           *trace.TraceFlags
	SeverityText         *string
	SeverityNumber       *SeverityNumber
	Body                 *string
	Resource             *resource.Resource
	InstrumentationScope *instrumentation.Scope
	Attributes           *[]attribute.KeyValue
}

type Logger interface {
	// Emit emits a log record
	Emit(logRecord LogRecord)
}

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

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

type LoggerProvider interface {
	// Logger returns a unique Logger scoped to be used by instrumentation code
	// to log computational workflows. The scope and identity of that
	// instrumentation code is uniquely defined by the name and options passed.
	//
	// The passed name needs to uniquely identify instrumentation code.
	// Therefore, it is recommended that name is the Go package name of the
	// library providing instrumentation (note: not the code being
	// instrumented). Instrumentation libraries can have multiple versions,
	// therefore, the WithInstrumentationVersion option should be used to
	// distinguish these different codebases. Additionally, instrumentation
	// libraries may sometimes use traces to communicate different domains of
	// workflow data (i.e. using logs to communicate workflow events only). If
	// this is the case, the WithScopeAttributes option should be used to
	// uniquely identify Loggers that handle the different domains of workflow
	// data.
	//
	// If the same name and options are passed multiple times, the same Logger
	// will be returned (it is up to the implementation if this will be the
	// same underlying instance of that Logger or not). It is not necessary to
	// call this multiple times with the same name and options to get an
	// up-to-date Logger. All implementations will ensure any LoggerProvider
	// configuration changes are propagated to all provided Loggers.
	//
	// If name is empty, then an implementation defined default name will be
	// used instead.
	//
	// This method is safe to call concurrently.
	Logger(name string, options ...LoggerOption) Logger
}

type SeverityNumber int32