otelx

Documentation

Index

• Constants
• Variables
• func AddConfigSchema(c interface{ ... }) error
• func End(span trace.Span, err *error)
• func NewHandler(handler http.Handler, operation string, opts ...otelhttp.Option) http.Handler
• func SetupJaeger(t *Tracer, tracerName string, c *Config) (trace.Tracer, error)
• func SetupOTLP(t *Tracer, tracerName string, c *Config) (trace.Tracer, error)
• func SetupZipkin(t *Tracer, tracerName string, c *Config) (trace.Tracer, error)
• func StringAttrs(attrs map[string]string) []attribute.KeyValue
• func TraceHandler(h http.Handler, opts ...otelhttp.Option) http.Handler
• func WithSpan(ctx context.Context, name string, f func(context.Context) error, ...) (err error)
• type Config
• type JaegerConfig
• type JaegerSampling
• type OTLPConfig
• type OTLPSampling
• type ProvidersConfig
• type Tracer
  • func New(name string, l *logrusx.Logger, c *Config) (*Tracer, error)
  • func NewNoop(_ *logrusx.Logger, c *Config) *Tracer
  • func (t *Tracer) IsLoaded() bool
  • func (t *Tracer) Provider() trace.TracerProvider
  • func (t *Tracer) Tracer() trace.Tracer
  • func (t *Tracer) WithOTLP(other trace.Tracer) *Tracer
• type ZipkinConfig
• type ZipkinSampling

Constants

const ConfigSchemaID = "ory://tracing-config"

Variables

var ConfigSchema string

Functions

func AddConfigSchema

func AddConfigSchema(c interface {
	AddResource(url string, r io.Reader) error
}) error

AddConfigSchema adds the tracing schema to the compiler. The interface is specified instead of `jsonschema.Compiler` to allow the use of any jsonschema library fork or version.

func End

func End(span trace.Span, err *error)

End finishes span, and automatically sets the error state if *err is not nil or during panicking.

Usage:

func Divide(ctx context.Context, numerator, denominator int) (ratio int, err error) {
	ctx, span := tracer.Start(ctx, "my-operation")
	defer otelx.End(span, &err)
	if denominator == 0 {
		return 0, errors.New("cannot divide by zero")
	}
	return numerator / denominator, nil
}

func NewHandler

func NewHandler(handler http.Handler, operation string, opts ...otelhttp.Option) http.Handler

NewHandler returns a wrapped otelhttp.NewHandler with our request filters.

func SetupJaeger

func SetupJaeger(t *Tracer, tracerName string, c *Config) (trace.Tracer, error)

SetupJaeger configures and returns a Jaeger tracer.

The returned tracer will by default attempt to send spans to a local Jaeger agent. Optionally, otelx.JaegerConfig.LocalAgentAddress can be set to specify a different target.

By default, unless a parent sampler has taken a sampling decision, every span is sampled. otelx.JaegerSampling.TraceIdRatio may be used to customize the sampling probability, optionally alongside otelx.JaegerSampling.ServerURL to consult a remote server for the sampling strategy to be used.

func SetupOTLP

func SetupOTLP(t *Tracer, tracerName string, c *Config) (trace.Tracer, error)

func SetupZipkin

func SetupZipkin(t *Tracer, tracerName string, c *Config) (trace.Tracer, error)

func StringAttrs

func StringAttrs(attrs map[string]string) []attribute.KeyValue

func TraceHandler

func TraceHandler(h http.Handler, opts ...otelhttp.Option) http.Handler

TraceHandler wraps otelx.NewHandler, passing the URL path as the span name.

func WithSpan

func WithSpan(ctx context.Context, name string, f func(context.Context) error, opts ...trace.SpanStartOption) (err error)

WithSpan wraps execution of f in a span identified by name.

If f returns an error or panics, the span status will be set to the error state. The error (or panic) will be propagated unmodified.

f will be wrapped in a child span by default. To make a new root span instead, pass the trace.WithNewRoot() option.

Types

type Config

type Config struct {
	ServiceName           string          `json:"service_name"`
	DeploymentEnvironment string          `json:"deployment_environment"`
	Provider              string          `json:"provider"`
	Providers             ProvidersConfig `json:"providers"`
}

type JaegerConfig

type JaegerConfig struct {
	LocalAgentAddress string         `json:"local_agent_address"`
	Sampling          JaegerSampling `json:"sampling"`
}

type JaegerSampling

type JaegerSampling struct {
	ServerURL    string  `json:"server_url"`
	TraceIdRatio float64 `json:"trace_id_ratio"`
}

type OTLPConfig

type OTLPConfig struct {
	ServerURL           string       `json:"server_url"`
	Insecure            bool         `json:"insecure"`
	Sampling            OTLPSampling `json:"sampling"`
	AuthorizationHeader string       `json:"authorization_header"`
}

type OTLPSampling

type OTLPSampling struct {
	SamplingRatio float64 `json:"sampling_ratio"`
}

type ProvidersConfig

type ProvidersConfig struct {
	Jaeger JaegerConfig `json:"jaeger"`
	Zipkin ZipkinConfig `json:"zipkin"`
	OTLP   OTLPConfig   `json:"otlp"`
}

type Tracer

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

func New

func New(name string, l *logrusx.Logger, c *Config) (*Tracer, error)

Creates a new tracer. If name is empty, a default tracer name is used instead. See: https://godocs.io/go.opentelemetry.io/otel/sdk/trace#TracerProvider.Tracer

func NewNoop

func NewNoop(_ *logrusx.Logger, c *Config) *Tracer

Creates a new no-op tracer.

func (*Tracer) IsLoaded

func (t *Tracer) IsLoaded() bool

IsLoaded returns true if the tracer has been loaded.

func (*Tracer) Provider

func (t *Tracer) Provider() trace.TracerProvider

Provider returns a TracerProvider which in turn yields this tracer unmodified.

func (*Tracer) Tracer

func (t *Tracer) Tracer() trace.Tracer

Tracer returns the underlying OpenTelemetry tracer.

func (*Tracer) WithOTLP

func (t *Tracer) WithOTLP(other trace.Tracer) *Tracer

WithOTLP returns a new tracer with the underlying OpenTelemetry Tracer replaced.

type ZipkinConfig

type ZipkinConfig struct {
	ServerURL string         `json:"server_url"`
	Sampling  ZipkinSampling `json:"sampling"`
}

type ZipkinSampling

type ZipkinSampling struct {
	SamplingRatio float64 `json:"sampling_ratio"`
}