package metric

import "go.opentelemetry.io/otel/internal/metric"

Index ¶

• Variables
• type Async
• func (a *Async) Implementation() interface{}
• type AsyncCollector
• type AsyncInstrumentState
• func NewAsyncInstrumentState() *AsyncInstrumentState
• func (a *AsyncInstrumentState) Instruments() []metric.AsyncImpl
• func (a *AsyncInstrumentState) Register(inst metric.AsyncImpl, runner metric.AsyncRunner)
• func (a *AsyncInstrumentState) Run(ctx context.Context, collector AsyncCollector)
• type Batch
• type Handle
• func (h *Handle) RecordOne(ctx context.Context, number apimetric.Number)
• func (h *Handle) Unbind()
• type Instrument
• func (i Instrument) Descriptor() apimetric.Descriptor
• type Measurement
• type MeterImpl
• func NewMeter() (*MeterImpl, apimetric.Meter)
• func NewProvider() (*MeterImpl, apimetric.Provider)
• func (m *MeterImpl) CollectAsync(labels []label.KeyValue, obs ...metric.Observation)
• func (m *MeterImpl) NewAsyncInstrument(descriptor metric.Descriptor, runner metric.AsyncRunner) (apimetric.AsyncImpl, error)
• func (m *MeterImpl) NewSyncInstrument(descriptor metric.Descriptor) (apimetric.SyncImpl, error)
• func (m *MeterImpl) RecordBatch(ctx context.Context, labels []label.KeyValue, measurements ...apimetric.Measurement)
• func (m *MeterImpl) RunAsyncInstruments()
• type Sync
• func (s *Sync) Bind(labels []label.KeyValue) apimetric.BoundSyncImpl
• func (s *Sync) Implementation() interface{}
• func (s *Sync) RecordOne(ctx context.Context, number apimetric.Number, labels []label.KeyValue)

Variables ¶

var ErrInvalidAsyncRunner = errors.New("unknown async runner type")

Types ¶

type Async ¶

type Async struct {
	Instrument
	// contains filtered or unexported fields
}

func (*Async) Implementation ¶

func (a *Async) Implementation() interface{}

type AsyncCollector ¶

type AsyncCollector interface {
	// CollectAsync passes a batch of observations to the MeterImpl.
	CollectAsync([]label.KeyValue, ...metric.Observation)
}

AsyncCollector is an interface used between the MeterImpl and the AsyncInstrumentState helper below. This interface is implemented by the SDK to provide support for running observer callbacks.

type AsyncInstrumentState ¶

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

AsyncInstrumentState manages an ordered set of asynchronous instruments and the distinct runners, taking into account batch observer callbacks.

func NewAsyncInstrumentState ¶

func NewAsyncInstrumentState() *AsyncInstrumentState

NewAsyncInstrumentState returns a new *AsyncInstrumentState, for use by MeterImpl to manage running the set of observer callbacks in the correct order.

func (*AsyncInstrumentState) Instruments ¶

func (a *AsyncInstrumentState) Instruments() []metric.AsyncImpl

Instruments returns the asynchronous instruments managed by this object, the set that should be checkpointed after observers are run.

func (*AsyncInstrumentState) Register ¶

func (a *AsyncInstrumentState) Register(inst metric.AsyncImpl, runner metric.AsyncRunner)

Register adds a new asynchronous instrument to by managed by this object. This should be called during NewAsyncInstrument() and assumes that errors (e.g., duplicate registration) have already been checked.

func (*AsyncInstrumentState) Run ¶

func (a *AsyncInstrumentState) Run(ctx context.Context, collector AsyncCollector)

Run executes the complete set of observer callbacks.

type Batch ¶

type Batch struct {
	// Measurement needs to be aligned for 64-bit atomic operations.
	Measurements []Measurement
	Ctx          context.Context
	Labels       []label.KeyValue
	LibraryName  string
}

type Handle ¶

type Handle struct {
	Instrument *Sync
	Labels     []label.KeyValue
}

func (*Handle) RecordOne ¶

func (h *Handle) RecordOne(ctx context.Context, number apimetric.Number)

func (*Handle) Unbind ¶

func (h *Handle) Unbind()

type Instrument ¶

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

func (Instrument) Descriptor ¶

func (i Instrument) Descriptor() apimetric.Descriptor

type Measurement ¶

type Measurement struct {
	// Number needs to be aligned for 64-bit atomic operations.
	Number     apimetric.Number
	Instrument apimetric.InstrumentImpl
}

type MeterImpl ¶

type MeterImpl struct {
	MeasurementBatches []Batch
	// contains filtered or unexported fields
}

func NewMeter ¶

func NewMeter() (*MeterImpl, apimetric.Meter)

func NewProvider ¶

func NewProvider() (*MeterImpl, apimetric.Provider)

func (*MeterImpl) CollectAsync ¶

func (m *MeterImpl) CollectAsync(labels []label.KeyValue, obs ...metric.Observation)

func (*MeterImpl) NewAsyncInstrument ¶

func (m *MeterImpl) NewAsyncInstrument(descriptor metric.Descriptor, runner metric.AsyncRunner) (apimetric.AsyncImpl, error)

func (*MeterImpl) NewSyncInstrument ¶

func (m *MeterImpl) NewSyncInstrument(descriptor metric.Descriptor) (apimetric.SyncImpl, error)

func (*MeterImpl) RecordBatch ¶

func (m *MeterImpl) RecordBatch(ctx context.Context, labels []label.KeyValue, measurements ...apimetric.Measurement)

func (*MeterImpl) RunAsyncInstruments ¶

func (m *MeterImpl) RunAsyncInstruments()

type Sync ¶

type Sync struct {
	Instrument
}

func (*Sync) Bind ¶

func (s *Sync) Bind(labels []label.KeyValue) apimetric.BoundSyncImpl

func (*Sync) Implementation ¶

func (s *Sync) Implementation() interface{}

func (*Sync) RecordOne ¶

func (s *Sync) RecordOne(ctx context.Context, number apimetric.Number, labels []label.KeyValue)

Source Files ¶

async.go mock.go