go/opentelemetry-go
go/opentelemetry-go
1
0
Fork 0
mirror of https://github.com/open-telemetry/opentelemetry-go.git synced 2025-01-01 22:09:57 +02:00
Code Issues Releases Activity

Golang metrics prototype (#100)

Browse Source 
* initial metrics work

* rename cumulative to counter

* rename bidirectional to nonmonotonic

* rename unidirectional to monotonic

* rename nonnegative to signed

this changes the default semantics a bit - before the change measure
could record negative values by default, now it can't.

The specification draft currently specifies both NonNegative and
Signed, but I think it's a mistake.

* rename instrument to descriptor

* license

* rework measurement values

* make measurement value a tagged union

* simplify to one kind of metrics

* add observers

* change some interfaces to match the spec

* keep integral measurement separate from floating ones

* remove duplicated measurement type

* add checking for options

* reorder some fields and functions

* rename a function

to avoid confusion between the Handle type and the Measure type

* drop disabled field from descriptor

* add back typed API for metrics

* make metric options type safe

* merge alternatives into a single bool

* make value kind name less stuttery

* fix observation callback prototype

* drop context parameter from NewHandle

* drop useless parameter names

* make descriptor an opaque struct

* use a store helper

* handle comment fixes

* reword Alternate comment

* drop the "any value" metrics

* make measurement value simpler

* document value stuff

* add tests for values

* docs

* do not panic if there is no span ID in the event
This commit is contained in:
Joshua MacDonald 2019-10-08 15:45:49 -07:00 committed by rghetia
parent c2d5c66990
commit be8fb0b4e2
26 changed files with 1638 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
api/core/key.go
View File

@ -25,6 +25,7 @@ type Value struct {
String string
Bytes []byte
// TODO See how segmentio/stats handles this type, it's much smaller.
// TODO Lazy value type?
}

325
api/metric/api.go
View File

@ -12,6 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//go:generate stringer -type=Kind,ValueKind
package metric
import (
@ -21,62 +23,317 @@ import (
"go.opentelemetry.io/api/unit"
)
type MetricType int
// Kind categorizes different kinds of metric.
type Kind int
const (
Invalid MetricType = iota
Gauge // Supports Set()
Cumulative // Supports Inc()
// Invalid describes an invalid metric.
Invalid Kind = iota
// CounterKind describes a metric that supports Add().
CounterKind
// GaugeKind describes a metric that supports Set().
GaugeKind
// MeasureKind describes a metric that supports Record().
MeasureKind
// ObserverKind describes a metric that reports measurement on
// demand.
ObserverKind
)
// Handle is the implementation-level interface to Set/Add/Record
// individual metrics.
type Handle interface {
// RecordOne allows the SDK to observe a single metric event
RecordOne(ctx context.Context, value MeasurementValue)
}
// TODO this belongs outside the metrics API, in some sense, but that
// might create a dependency. Putting this here means we can't re-use
// a LabelSet between metrics and tracing, even when they are the same
// SDK.
// LabelSet represents a []core.KeyValue for use as pre-defined labels
// in the metrics API.
type LabelSet interface {
Meter() Meter
}
// ObservationCallback defines a type of the callback the observer
// will use to report the measurement
type ObservationCallback func(LabelSet, MeasurementValue)
// ObserverCallback defines a type of the callback SDK will call for
// the registered observers.
type ObserverCallback func(Meter, Observer, ObservationCallback)
// Meter is an interface to the metrics portion of the OpenTelemetry SDK.
type Meter interface {
// TODO more Metric types
GetFloat64Gauge(ctx context.Context, gauge *Float64GaugeHandle, labels ...core.KeyValue) Float64Gauge
// DefineLabels returns a reference to a set of labels that
// cannot be read by the application.
DefineLabels(context.Context, ...core.KeyValue) LabelSet
// RecordBatch atomically records a batch of measurements.
RecordBatch(context.Context, LabelSet, ...Measurement)
// NewHandle creates a Handle that contains the passed
// key-value pairs. This should not be used directly - prefer
// using GetHandle function of a metric.
NewHandle(*Descriptor, LabelSet) Handle
// DeleteHandle destroys the Handle and does a cleanup of the
// underlying resources.
DeleteHandle(Handle)
// RegisterObserver registers the observer with callback
// returning a measurement. When and how often the callback
// will be called is defined by SDK. This should not be used
// directly - prefer either RegisterInt64Observer or
// RegisterFloat64Observer, depending on the type of the
// observer to be registered.
RegisterObserver(Observer, ObserverCallback)
// UnregisterObserver removes the observer from registered
// observers. This should not be used directly - prefer either
// UnregisterInt64Observer or UnregisterFloat64Observer,
// depending on the type of the observer to be registered.
UnregisterObserver(Observer)
}
type Float64Gauge interface {
Set(ctx context.Context, value float64, labels ...core.KeyValue)
// DescriptorID is a unique identifier of a metric.
type DescriptorID uint64
// ValueKind describes the data type of the measurement value the
// metric generates.
type ValueKind int8
const (
// Int64ValueKind means that the metric generates values of
// type int64.
Int64ValueKind ValueKind = iota
// Float64ValueKind means that the metric generates values of
// type float64.
Float64ValueKind
)
// Descriptor represents a named metric with recommended
// local-aggregation keys.
type Descriptor struct {
name string
kind Kind
keys []core.Key
id DescriptorID
description string
unit unit.Unit
valueKind ValueKind
alternate bool
}
type Handle struct {
Name string
Description string
Unit unit.Unit
Type MetricType
Keys []core.Key
// Name is a required field describing this metric descriptor, should
// have length > 0.
func (d *Descriptor) Name() string {
return d.name
}
type Option func(*Handle)
// Kind is the metric kind of this descriptor.
func (d *Descriptor) Kind() Kind {
return d.kind
}
// Keys are recommended keys determined in the handles obtained for
// this metric.
func (d *Descriptor) Keys() []core.Key {
return d.keys
}
// ID is uniquely assigned to support per-SDK registration.
func (d *Descriptor) ID() DescriptorID {
return d.id
}
// Description is an optional field describing this metric descriptor.
func (d *Descriptor) Description() string {
return d.description
}
// Unit is an optional field describing this metric descriptor.
func (d *Descriptor) Unit() unit.Unit {
return d.unit
}
// ValueKind describes the type of values the metric produces.
func (d *Descriptor) ValueKind() ValueKind {
return d.valueKind
}
// Alternate defines the property of metric value dependent on a
// metric type.
//
// - for Counter, true implies that the metric is an up-down Counter
//
// - for Gauge/Observer, true implies that the metric is a
// non-descending Gauge/Observer
//
// - for Measure, true implies that the metric supports positive and
// negative values
func (d *Descriptor) Alternate() bool {
return d.alternate
}
// Measurement is used for reporting a batch of metric values.
type Measurement struct {
Descriptor *Descriptor
Value MeasurementValue
}
// Option supports specifying the various metric options.
type Option func(*Descriptor)
// OptionApplier is an interface for applying metric options that are
// valid for all the kinds of metrics.
type OptionApplier interface {
CounterOptionApplier
GaugeOptionApplier
MeasureOptionApplier
// ApplyOption is used to make some changes in the Descriptor.
ApplyOption(*Descriptor)
}
type optionWrapper struct {
F Option
}
var _ OptionApplier = optionWrapper{}
func (o optionWrapper) ApplyCounterOption(d *Descriptor) {
o.ApplyOption(d)
}
func (o optionWrapper) ApplyGaugeOption(d *Descriptor) {
o.ApplyOption(d)
}
func (o optionWrapper) ApplyMeasureOption(d *Descriptor) {
o.ApplyOption(d)
}
func (o optionWrapper) ApplyOption(d *Descriptor) {
o.F(d)
}
// WithDescription applies provided description.
func WithDescription(desc string) Option {
return func(m *Handle) {
m.Description = desc
func WithDescription(desc string) OptionApplier {
return optionWrapper{
F: func(d *Descriptor) {
d.description = desc
},
}
}
// WithUnit applies provided unit.
func WithUnit(unit unit.Unit) Option {
return func(m *Handle) {
m.Unit = unit
func WithUnit(unit unit.Unit) OptionApplier {
return optionWrapper{
F: func(d *Descriptor) {
d.unit = unit
},
}
}
// WithKeys applies the provided dimension keys.
func WithKeys(keys ...core.Key) Option {
return func(m *Handle) {
m.Keys = keys
// WithKeys applies required label keys. Multiple `WithKeys` options
// accumulate.
func WithKeys(keys ...core.Key) OptionApplier {
return optionWrapper{
F: func(d *Descriptor) {
d.keys = append(d.keys, keys...)
},
}
}
func (mtype MetricType) String() string {
switch mtype {
case Gauge:
return "gauge"
case Cumulative:
return "cumulative"
default:
return "unknown"
// WithNonMonotonic sets whether a counter is permitted to go up AND
// down.
func WithNonMonotonic(nm bool) CounterOptionApplier {
return counterOptionWrapper{
F: func(d *Descriptor) {
d.alternate = nm
},
}
}
// WithMonotonic sets whether a gauge is not permitted to go down.
func WithMonotonic(m bool) GaugeOptionApplier {
return gaugeOptionWrapper{
F: func(d *Descriptor) {
d.alternate = m
},
}
}
// WithSigned sets whether a measure is permitted to be negative.
func WithSigned(s bool) MeasureOptionApplier {
return measureOptionWrapper{
F: func(d *Descriptor) {
d.alternate = s
},
}
}
// Defined returns true when the descriptor has been registered.
func (d Descriptor) Defined() bool {
return len(d.name) != 0
}
// RecordBatch reports to the global Meter.
func RecordBatch(ctx context.Context, labels LabelSet, batch ...Measurement) {
GlobalMeter().RecordBatch(ctx, labels, batch...)
}
// Int64ObservationCallback defines a type of the callback the
// observer will use to report the int64 measurement.
type Int64ObservationCallback func(LabelSet, int64)
// Int64ObserverCallback defines a type of the callback SDK will call
// for the registered int64 observers.
type Int64ObserverCallback func(Meter, Int64Observer, Int64ObservationCallback)
// RegisterInt64Observer is a convenience wrapper around
// Meter.RegisterObserver that provides a type-safe callback for
// Int64Observer.
func RegisterInt64Observer(meter Meter, observer Int64Observer, callback Int64ObserverCallback) {
cb := func(m Meter, o Observer, ocb ObservationCallback) {
iocb := func(l LabelSet, i int64) {
ocb(l, NewInt64MeasurementValue(i))
}
callback(m, Int64Observer{o}, iocb)
}
meter.RegisterObserver(observer.Observer, cb)
}
// UnregisterInt64Observer is a convenience wrapper around
// Meter.UnregisterObserver for Int64Observer.
func UnregisterInt64Observer(meter Meter, observer Int64Observer) {
meter.UnregisterObserver(observer.Observer)
}
// Float64ObservationCallback defines a type of the callback the
// observer will use to report the float64 measurement.
type Float64ObservationCallback func(LabelSet, float64)
// Float64ObserverCallback defines a type of the callback SDK will
// call for the registered float64 observers.
type Float64ObserverCallback func(Meter, Float64Observer, Float64ObservationCallback)
// RegisterFloat64Observer is a convenience wrapper around
// Meter.RegisterObserver that provides a type-safe callback for
// Float64Observer.
func RegisterFloat64Observer(meter Meter, observer Float64Observer, callback Float64ObserverCallback) {
cb := func(m Meter, o Observer, ocb ObservationCallback) {
focb := func(l LabelSet, f float64) {
ocb(l, NewFloat64MeasurementValue(f))
}
callback(m, Float64Observer{o}, focb)
}
meter.RegisterObserver(observer.Observer, cb)
}
// UnregisterFloat64Observer is a convenience wrapper around
// Meter.UnregisterObserver for Float64Observer.
func UnregisterFloat64Observer(meter Meter, observer Float64Observer) {
meter.UnregisterObserver(observer.Observer)
}

61
api/metric/common.go
View File

@ -14,11 +14,60 @@
package metric
func registerMetric(name string, mtype MetricType, opts []Option, metric *Handle) {
for _, opt := range opts {
opt(metric)
}
import (
"context"
"sync/atomic"
)
metric.Name = name
metric.Type = mtype
var (
descriptorID uint64
)
// TODO: Maybe unexport that and document very _very_ clearly, that
// you can still get a descriptor with NewInt64Counter(…).Descriptor
// CommonMetric holds a descriptor. It is used mostly to implement the
// common parts for every metric kind.
type CommonMetric struct {
*Descriptor
}
func (m CommonMetric) getHandle(labels LabelSet) Handle {
return labels.Meter().NewHandle(m.Descriptor, labels)
}
func (m CommonMetric) float64Measurement(value float64) Measurement {
return Measurement{
Descriptor: m.Descriptor,
Value: NewFloat64MeasurementValue(value),
}
}
func (m CommonMetric) int64Measurement(value int64) Measurement {
return Measurement{
Descriptor: m.Descriptor,
Value: NewInt64MeasurementValue(value),
}
}
func (m CommonMetric) recordOne(ctx context.Context, value MeasurementValue, labels LabelSet) {
labels.Meter().RecordBatch(ctx, labels, Measurement{
Descriptor: m.Descriptor,
Value: value,
})
}
func registerCommonMetric(name string, kind Kind, valueKind ValueKind) CommonMetric {
return CommonMetric{
Descriptor: registerDescriptor(name, kind, valueKind),
}
}
func registerDescriptor(name string, kind Kind, valueKind ValueKind) *Descriptor {
return &Descriptor{
name: name,
kind: kind,
valueKind: valueKind,
id: DescriptorID(atomic.AddUint64(&descriptorID, 1)),
}
}

129
api/metric/counter.go Normal file
View File

@ -0,0 +1,129 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package metric
import (
"context"
)
// Float64Counter is a metric that accumulates float64 values.
type Float64Counter struct {
CommonMetric
}
// Int64Counter is a metric that accumulates int64 values.
type Int64Counter struct {
CommonMetric
}
// Float64CounterHandle is a handle for Float64Counter.
type Float64CounterHandle struct {
Handle
}
// Int64CounterHandle is a handle for Int64Counter.
type Int64CounterHandle struct {
Handle
}
// CounterOptionApplier is an interface for applying metric options
// that are valid only for counter metrics.
type CounterOptionApplier interface {
// ApplyCounterOption is used to make some counter-specific
// changes in the Descriptor.
ApplyCounterOption(*Descriptor)
}
type counterOptionWrapper struct {
F Option
}
var _ CounterOptionApplier = counterOptionWrapper{}
func (o counterOptionWrapper) ApplyCounterOption(d *Descriptor) {
o.F(d)
}
func newCounter(name string, valueKind ValueKind, mos ...CounterOptionApplier) CommonMetric {
m := registerCommonMetric(name, CounterKind, valueKind)
for _, opt := range mos {
opt.ApplyCounterOption(m.Descriptor)
}
return m
}
// NewFloat64Counter creates a new counter for float64.
func NewFloat64Counter(name string, mos ...CounterOptionApplier) (c Float64Counter) {
c.CommonMetric = newCounter(name, Float64ValueKind, mos...)
return
}
// NewInt64Counter creates a new counter for int64.
func NewInt64Counter(name string, mos ...CounterOptionApplier) (c Int64Counter) {
c.CommonMetric = newCounter(name, Int64ValueKind, mos...)
return
}
// GetHandle creates a handle for this counter. The labels should
// contain the keys and values specified in the counter with the
// WithKeys option.
func (c *Float64Counter) GetHandle(labels LabelSet) (h Float64CounterHandle) {
h.Handle = c.getHandle(labels)
return
}
// GetHandle creates a handle for this counter. The labels should
// contain the keys and values specified in the counter with the
// WithKeys option.
func (c *Int64Counter) GetHandle(labels LabelSet) (h Int64CounterHandle) {
h.Handle = c.getHandle(labels)
return
}
// Measurement creates a Measurement object to use with batch
// recording.
func (c *Float64Counter) Measurement(value float64) Measurement {
return c.float64Measurement(value)
}
// Measurement creates a Measurement object to use with batch
// recording.
func (c *Int64Counter) Measurement(value int64) Measurement {
return c.int64Measurement(value)
}
// Add adds the value to the counter's sum. The labels should contain
// the keys and values specified in the counter with the WithKeys
// option.
func (c *Float64Counter) Add(ctx context.Context, value float64, labels LabelSet) {
c.recordOne(ctx, NewFloat64MeasurementValue(value), labels)
}
// Add adds the value to the counter's sum. The labels should contain
// the keys and values specified in the counter with the WithKeys
// option.
func (c *Int64Counter) Add(ctx context.Context, value int64, labels LabelSet) {
c.recordOne(ctx, NewInt64MeasurementValue(value), labels)
}
// Add adds the value to the counter's sum.
func (h *Float64CounterHandle) Add(ctx context.Context, value float64) {
h.RecordOne(ctx, NewFloat64MeasurementValue(value))
}
// Add adds the value to the counter's sum.
func (h *Int64CounterHandle) Add(ctx context.Context, value int64) {
h.RecordOne(ctx, NewInt64MeasurementValue(value))
}

64
api/metric/doc.go
View File

@ -12,4 +12,68 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// metric package provides an API for reporting diagnostic
// measurements using three basic kinds of instruments (or four, if
// calling one special case a separate one).
//
// The three basic kinds are:
//
// - counters
// - gauges
// - measures
//
// There is also a special case of a gauge instrument called
// observer. It will be discussed later.
//
// All instruments report either float64 or int64 values.
//
// The primary object that handles metrics is Meter. The
// implementation of the Meter is provided by SDK. Normally, the Meter
// is used directly only for the LabelSet generation, batch recording
// and the handle destruction.
//
// LabelSet is a set of keys and values that are in a suitable,
// optimized form to be used by Meter.
//
// Counters are instruments that are reporting a quantity or a sum. An
// example could be bank account balance or bytes downloaded. Counters
// can be created with either NewFloat64Counter or
// NewInt64Counter. Counters expect non-negative values by default to
// be reported. This can be changed with the WithNonMonotonic option
// passed to the New*Counter function - this allows reporting negative
// values. To report the new value, use an Add function.
//
// Gauges are instruments that are reporting a current state of a
// value. An example could be voltage or temperature. Gauges can be
// created with either NewFloat64Gauge or NewInt64Gauge. Gauges by
// default have no limitations about reported values - they can be
// less or greater than the last reported value. This can be changed
// with the WithMonotonic option passed to the New*Gauge function -
// this permits the reported values only to go up. To report a new
// value, use the Set function.
//
// Measures are instruments that are reporting values that are
// recorded separately to figure out some statistical properties from
// those values (like average). An example could be temperature over
// time or lines of code in the project over time. Measures can be
// created with either NewFloat64Measure or NewInt64Measure. Measures
// by default take only non-negative values. This can be changed with
// the WithSigned option passed to the New*Measure function - this
// allows reporting negative values too. To report a new value, use
// the Record function.
//
// A special case of a gauge is observer. It has the same role as
// gauge, but reports values in a different way. The observer can be
// created with NewFloat64Observer or NewInt64Observer and then
// registered within a Meter with either RegisterInt64Observer or
// RegisterFloat64Observer functions. These take a callback for
// reporting the values. The callback will be called by the Meter when
// it deems it necessary.
//
// All the basic kinds of instruments (so, not observers) also support
// creating handles for a potentially more efficient reporting. The
// handles have the same function names as the instruments (so counter
// handle has Add, gauge handle has Set and measure handle has
// Record). Handles can be created with the GetHandle function of the
// respective instrument.
package metric // import "go.opentelemetry.io/api/metric"

112
api/metric/gauge.go
View File

@ -14,12 +14,116 @@
package metric
import (
"context"
)
// Float64Gauge is a metric that stores the last float64 value.
type Float64Gauge struct {
CommonMetric
}
// Int64Gauge is a metric that stores the last int64 value.
type Int64Gauge struct {
CommonMetric
}
// Float64GaugeHandle is a handle for Float64Gauge.
type Float64GaugeHandle struct {
Handle
}
func NewFloat64Gauge(name string, mos ...Option) *Float64GaugeHandle {
g := &Float64GaugeHandle{}
registerMetric(name, Gauge, mos, &g.Handle)
return g
// Int64GaugeHandle is a handle for Int64Gauge.
type Int64GaugeHandle struct {
Handle
}
// GaugeOptionApplier is an interface for applying metric options that
// are valid only for gauge metrics.
type GaugeOptionApplier interface {
// ApplyGaugeOption is used to make some gauge-specific
// changes in the Descriptor.
ApplyGaugeOption(*Descriptor)
}
type gaugeOptionWrapper struct {
F Option
}
var _ GaugeOptionApplier = gaugeOptionWrapper{}
func (o gaugeOptionWrapper) ApplyGaugeOption(d *Descriptor) {
o.F(d)
}
func newGauge(name string, valueKind ValueKind, mos ...GaugeOptionApplier) CommonMetric {
m := registerCommonMetric(name, GaugeKind, valueKind)
for _, opt := range mos {
opt.ApplyGaugeOption(m.Descriptor)
}
return m
}
// NewFloat64Gauge creates a new gauge for float64.
func NewFloat64Gauge(name string, mos ...GaugeOptionApplier) (g Float64Gauge) {
g.CommonMetric = newGauge(name, Float64ValueKind, mos...)
return
}
// NewInt64Gauge creates a new gauge for int64.
func NewInt64Gauge(name string, mos ...GaugeOptionApplier) (g Int64Gauge) {
g.CommonMetric = newGauge(name, Int64ValueKind, mos...)
return
}
// GetHandle creates a handle for this gauge. The labels should
// contain the keys and values specified in the gauge with the
// WithKeys option.
func (g *Float64Gauge) GetHandle(labels LabelSet) (h Float64GaugeHandle) {
h.Handle = g.getHandle(labels)
return
}
// GetHandle creates a handle for this gauge. The labels should
// contain the keys and values specified in the gauge with the
// WithKeys option.
func (g *Int64Gauge) GetHandle(labels LabelSet) (h Int64GaugeHandle) {
h.Handle = g.getHandle(labels)
return
}
// Measurement creates a Measurement object to use with batch
// recording.
func (g *Float64Gauge) Measurement(value float64) Measurement {
return g.float64Measurement(value)
}
// Measurement creates a Measurement object to use with batch
// recording.
func (g *Int64Gauge) Measurement(value int64) Measurement {
return g.int64Measurement(value)
}
// Set sets the value of the gauge to the passed value. The labels
// should contain the keys and values specified in the gauge with the
// WithKeys option.
func (g *Float64Gauge) Set(ctx context.Context, value float64, labels LabelSet) {
g.recordOne(ctx, NewFloat64MeasurementValue(value), labels)
}
// Set sets the value of the gauge to the passed value. The labels
// should contain the keys and values specified in the gauge with the
// WithKeys option.
func (g *Int64Gauge) Set(ctx context.Context, value int64, labels LabelSet) {
g.recordOne(ctx, NewInt64MeasurementValue(value), labels)
}
// Set sets the value of the gauge to the passed value.
func (h *Float64GaugeHandle) Set(ctx context.Context, value float64) {
h.RecordOne(ctx, NewFloat64MeasurementValue(value))
}
// Set sets the value of the gauge to the passed value.
func (h *Int64GaugeHandle) Set(ctx context.Context, value int64) {
h.RecordOne(ctx, NewInt64MeasurementValue(value))
}

6
api/metric/global.go
View File

@ -18,13 +18,13 @@ import "sync/atomic"
var global atomic.Value
// GlobalMeter return meter registered with global registry.
// If no meter is registered then an instance of noop Meter is returned.
// GlobalMeter returns a meter registered as a global meter. If no
// meter is registered then an instance of noop Meter is returned.
func GlobalMeter() Meter {
if t := global.Load(); t != nil {
return t.(Meter)
}
return NoopMeter{}
return noopMeter{}
}
// SetGlobalMeter sets provided meter as a global meter.

45
api/metric/kind_string.go Normal file
View File

@ -0,0 +1,45 @@
// Code generated by "stringer -type=Kind,ValueKind"; DO NOT EDIT.
package metric
import "strconv"
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[Invalid-0]
_ = x[CounterKind-1]
_ = x[GaugeKind-2]
_ = x[MeasureKind-3]
_ = x[ObserverKind-4]
}
const _Kind_name = "InvalidCounterKindGaugeKindMeasureKindObserverKind"
var _Kind_index = [...]uint8{0, 7, 18, 27, 38, 50}
func (i Kind) String() string {
if i < 0 || i >= Kind(len(_Kind_index)-1) {
return "Kind(" + strconv.FormatInt(int64(i), 10) + ")"
}
return _Kind_name[_Kind_index[i]:_Kind_index[i+1]]
}
func _() {
// An "invalid array index" compiler error signifies that the constant values have changed.
// Re-run the stringer command to generate them again.
var x [1]struct{}
_ = x[Int64ValueKind-0]
_ = x[Float64ValueKind-1]
}
const _ValueKind_name = "Int64ValueKindFloat64ValueKind"
var _ValueKind_index = [...]uint8{0, 14, 30}
func (i ValueKind) String() string {
if i < 0 || i >= ValueKind(len(_ValueKind_index)-1) {
return "ValueKind(" + strconv.FormatInt(int64(i), 10) + ")"
}
return _ValueKind_name[_ValueKind_index[i]:_ValueKind_index[i+1]]
}

129
api/metric/measure.go Normal file
View File

@ -0,0 +1,129 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package metric
import (
"context"
)
// Float64Measure is a metric that records float64 values.
type Float64Measure struct {
CommonMetric
}
// Int64Measure is a metric that records int64 values.
type Int64Measure struct {
CommonMetric
}
// Float64MeasureHandle is a handle for Float64Measure.
type Float64MeasureHandle struct {
Handle
}
// Int64MeasureHandle is a handle for Int64Measure.
type Int64MeasureHandle struct {
Handle
}
// MeasureOptionApplier is an interface for applying metric options
// that are valid only for measure metrics.
type MeasureOptionApplier interface {
// ApplyMeasureOption is used to make some measure-specific
// changes in the Descriptor.
ApplyMeasureOption(*Descriptor)
}
type measureOptionWrapper struct {
F Option
}
var _ MeasureOptionApplier = measureOptionWrapper{}
func (o measureOptionWrapper) ApplyMeasureOption(d *Descriptor) {
o.F(d)
}
func newMeasure(name string, valueKind ValueKind, mos ...MeasureOptionApplier) CommonMetric {
m := registerCommonMetric(name, MeasureKind, valueKind)
for _, opt := range mos {
opt.ApplyMeasureOption(m.Descriptor)
}
return m
}
// NewFloat64Measure creates a new measure for float64.
func NewFloat64Measure(name string, mos ...MeasureOptionApplier) (c Float64Measure) {
c.CommonMetric = newMeasure(name, Float64ValueKind, mos...)
return
}
// NewInt64Measure creates a new measure for int64.
func NewInt64Measure(name string, mos ...MeasureOptionApplier) (c Int64Measure) {
c.CommonMetric = newMeasure(name, Int64ValueKind, mos...)
return
}
// GetHandle creates a handle for this measure. The labels should
// contain the keys and values specified in the measure with the
// WithKeys option.
func (c *Float64Measure) GetHandle(labels LabelSet) (h Float64MeasureHandle) {
h.Handle = c.getHandle(labels)
return
}
// GetHandle creates a handle for this measure. The labels should
// contain the keys and values specified in the measure with the
// WithKeys option.
func (c *Int64Measure) GetHandle(labels LabelSet) (h Int64MeasureHandle) {
h.Handle = c.getHandle(labels)
return
}
// Measurement creates a Measurement object to use with batch
// recording.
func (c *Float64Measure) Measurement(value float64) Measurement {
return c.float64Measurement(value)
}
// Measurement creates a Measurement object to use with batch
// recording.
func (c *Int64Measure) Measurement(value int64) Measurement {
return c.int64Measurement(value)
}
// Record adds a new value to the list of measure's records. The
// labels should contain the keys and values specified in the measure
// with the WithKeys option.
func (c *Float64Measure) Record(ctx context.Context, value float64, labels LabelSet) {
c.recordOne(ctx, NewFloat64MeasurementValue(value), labels)
}
// Record adds a new value to the list of measure's records. The
// labels should contain the keys and values specified in the measure
// with the WithKeys option.
func (c *Int64Measure) Record(ctx context.Context, value int64, labels LabelSet) {
c.recordOne(ctx, NewInt64MeasurementValue(value), labels)
}
// Record adds a new value to the list of measure's records.
func (h *Float64MeasureHandle) Record(ctx context.Context, value float64) {
h.RecordOne(ctx, NewFloat64MeasurementValue(value))
}
// Record adds a new value to the list of measure's records.
func (h *Int64MeasureHandle) Record(ctx context.Context, value int64) {
h.RecordOne(ctx, NewInt64MeasurementValue(value))
}

38
api/metric/noop_meter.go
View File

@ -6,17 +6,37 @@ import (
"go.opentelemetry.io/api/core"
)
type NoopMeter struct{}
type noopMeter struct{}
type noopHandle struct{}
type noopLabelSet struct{}
type noopMetric struct{}
var _ Meter = noopMeter{}
var _ Handle = noopHandle{}
var _ LabelSet = noopLabelSet{}
var _ Meter = NoopMeter{}
var _ Float64Gauge = noopMetric{}
func (NoopMeter) GetFloat64Gauge(ctx context.Context, gauge *Float64GaugeHandle, labels ...core.KeyValue) Float64Gauge {
return noopMetric{}
func (noopHandle) RecordOne(context.Context, MeasurementValue) {
}
func (noopMetric) Set(ctx context.Context, value float64, labels ...core.KeyValue) {
func (noopLabelSet) Meter() Meter {
return noopMeter{}
}
func (noopMeter) DefineLabels(context.Context, ...core.KeyValue) LabelSet {
return noopLabelSet{}
}
func (noopMeter) NewHandle(*Descriptor, LabelSet) Handle {
return noopHandle{}
}
func (noopMeter) DeleteHandle(Handle) {
}
func (noopMeter) RecordBatch(context.Context, LabelSet, ...Measurement) {
}
func (noopMeter) RegisterObserver(Observer, ObserverCallback) {
}
func (noopMeter) UnregisterObserver(Observer) {
}

50
api/metric/observer.go Normal file
View File

@ -0,0 +1,50 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package metric
// Observer is a base of typed-observers. Shouldn't be used directly.
type Observer struct {
*Descriptor
}
// Float64Observer is an observer that reports float64 values.
type Float64Observer struct {
Observer
}
// Int64Observer is an observer that reports int64 values.
type Int64Observer struct {
Observer
}
func newObserver(name string, valueKind ValueKind, mos ...GaugeOptionApplier) (o Observer) {
o.Descriptor = registerDescriptor(name, ObserverKind, valueKind)
for _, opt := range mos {
opt.ApplyGaugeOption(o.Descriptor)
}
return
}
// NewFloat64Observer creates a new observer for float64.
func NewFloat64Observer(name string, mos ...GaugeOptionApplier) (o Float64Observer) {
o.Observer = newObserver(name, Float64ValueKind, mos...)
return
}
// NewInt64Observer creates a new observer for int64.
func NewInt64Observer(name string, mos ...GaugeOptionApplier) (o Int64Observer) {
o.Observer = newObserver(name, Int64ValueKind, mos...)
return
}

168
api/metric/value.go Normal file
View File

@ -0,0 +1,168 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package metric
import (
"fmt"
"math"
)
// MeasurementValue represents either an integral or a floating point
// value of a measurement. It needs to be accompanied with a
// descriptor of a metric that generated this value to decide what
// type of value it represents.
type MeasurementValue uint64
// NewInt64MeasurementValue creates an integral MeasurementValue.
func NewInt64MeasurementValue(i int64) MeasurementValue {
return newFromRaw(int64ToRaw(i))
}
// NewFloat64MeasurementValue creates a floating point
// MeasurementValue.
func NewFloat64MeasurementValue(f float64) MeasurementValue {
return newFromRaw(float64ToRaw(f))
}
func newFromRaw(raw uint64) MeasurementValue {
return MeasurementValue(raw)
}
// AsInt64 assumes that the measurement value contains an int64 and
// returns it as such. Make sure that metric that generated this value
// has indeed Int64ValueKind in its descriptor.
func (v MeasurementValue) AsInt64() int64 {
return rawToInt64(v.AsRaw())
}
// AsFloat64 assumes that the measurement value contains a float64 and
// returns it as such. Make sure that metric that generated this value
// has indeed Int64ValueKind in its descriptor.
func (v MeasurementValue) AsFloat64() float64 {
return rawToFloat64(v.AsRaw())
}
// AsRaw gets the raw, uninterpreted value of the measurement. Might
// be useful for some atomic operations.
func (v MeasurementValue) AsRaw() uint64 {
return uint64(v)
}
// AsRawPtr gets the pointer to the raw, uninterpreted value of the
// measurement. Might be useful for some atomic operations.
func (v *MeasurementValue) AsRawPtr() *uint64 {
return (*uint64)(v)
}
// Emit returns a string representation of the actual value of the
// MeasurementValue. A %d is used for integral values, %f for floating
// point values.
func (v MeasurementValue) Emit(kind ValueKind) string {
switch kind {
case Int64ValueKind:
return fmt.Sprintf("%d", v.AsInt64())
case Float64ValueKind:
return fmt.Sprintf("%f", v.AsFloat64())
default:
return ""
}
}
// Float64Compare assumes that the MeasurementValue contains a float64
// and performs a comparison between the value and the other value. It
// returns the typical result of the compare function: -1 if the value
// is less than the other, 0 if both are equal, 1 if the value is
// greater than the other.
func (v MeasurementValue) Float64Compare(other float64) int {
this := v.AsFloat64()
if this < other {
return -1
} else if this > other {
return 1
}
return 0
}
// Int64Compare assumes that the MeasurementValue contains an int64
// and performs a comparison between the value and the other value. It
// returns the typical result of the compare function: -1 if the value
// is less than the other, 0 if both are equal, 1 if the value is
// greater than the other.
func (v MeasurementValue) Int64Compare(other int64) int {
this := v.AsInt64()
if this < other {
return -1
} else if this > other {
return 1
}
return 0
}
// RawCompare calls either Float64Compare or Int64Compare, depending
// on the passed kind.
func (v MeasurementValue) RawCompare(other uint64, kind ValueKind) int {
switch kind {
case Int64ValueKind:
return v.Int64Compare(rawToInt64(other))
case Float64ValueKind:
return v.Float64Compare(rawToFloat64(other))
default:
// you get what you deserve
return 0
}
}
// IsPositive returns true if the actual value is greater than zero.
func (v MeasurementValue) IsPositive(kind ValueKind) bool {
return v.compareWithZero(kind) > 0
}
// IsNegative returns true if the actual value is less than zero.
func (v MeasurementValue) IsNegative(kind ValueKind) bool {
return v.compareWithZero(kind) < 0
}
// IsZero returns true if the actual value is equal to zero.
func (v MeasurementValue) IsZero(kind ValueKind) bool {
return v.compareWithZero(kind) == 0
}
func (v MeasurementValue) compareWithZero(kind ValueKind) int {
switch kind {
case Int64ValueKind:
return v.Int64Compare(0)
case Float64ValueKind:
return v.Float64Compare(0.)
default:
// you get what you deserve
return 0
}
}
func rawToFloat64(r uint64) float64 {
return math.Float64frombits(r)
}
func float64ToRaw(f float64) uint64 {
return math.Float64bits(f)
}
func rawToInt64(r uint64) int64 {
return int64(r)
}
func int64ToRaw(i int64) uint64 {
return uint64(i)
}

148
api/metric/value_test.go Normal file
View File

@ -0,0 +1,148 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package metric
import (
"testing"
"unsafe"
)
func TestMeasurementValue(t *testing.T) {
iNeg := NewInt64MeasurementValue(-42)
iZero := NewInt64MeasurementValue(0)
iPos := NewInt64MeasurementValue(42)
i64Values := [3]MeasurementValue{iNeg, iZero, iPos}
for idx, i := range []int64{-42, 0, 42} {
v := i64Values[idx]
if got := v.AsInt64(); got != i {
t.Errorf("Value %#v (%s) int64 check failed, expected %d, got %d", v, v.Emit(Int64ValueKind), i, got)
}
}
for _, v := range i64Values {
expected := unsafe.Pointer(&v)
got := unsafe.Pointer(v.AsRawPtr())
if expected != got {
t.Errorf("Getting raw pointer failed, got %v, expected %v", got, expected)
}
}
fNeg := NewFloat64MeasurementValue(-42.)
fZero := NewFloat64MeasurementValue(0.)
fPos := NewFloat64MeasurementValue(42.)
f64Values := [3]MeasurementValue{fNeg, fZero, fPos}
for idx, f := range []float64{-42., 0., 42.} {
v := f64Values[idx]
if got := v.AsFloat64(); got != f {
t.Errorf("Value %#v (%s) float64 check failed, expected %f, got %f", v, v.Emit(Int64ValueKind), f, got)
}
}
for _, v := range f64Values {
expected := unsafe.Pointer(&v)
got := unsafe.Pointer(v.AsRawPtr())
if expected != got {
t.Errorf("Getting raw pointer failed, got %v, expected %v", got, expected)
}
}
cmpsForNeg := [3]int{0, -1, -1}
cmpsForZero := [3]int{1, 0, -1}
cmpsForPos := [3]int{1, 1, 0}
type testcase struct {
v MeasurementValue
kind ValueKind
pos bool
zero bool
neg bool
vals [3]MeasurementValue
cmps [3]int
}
testcases := []testcase{
{
v: iNeg,
kind: Int64ValueKind,
pos: false,
zero: false,
neg: true,
vals: i64Values,
cmps: cmpsForNeg,
},
{
v: iZero,
kind: Int64ValueKind,
pos: false,
zero: true,
neg: false,
vals: i64Values,
cmps: cmpsForZero,
},
{
v: iPos,
kind: Int64ValueKind,
pos: true,
zero: false,
neg: false,
vals: i64Values,
cmps: cmpsForPos,
},
{
v: fNeg,
kind: Float64ValueKind,
pos: false,
zero: false,
neg: true,
vals: f64Values,
cmps: cmpsForNeg,
},
{
v: fZero,
kind: Float64ValueKind,
pos: false,
zero: true,
neg: false,
vals: f64Values,
cmps: cmpsForZero,
},
{
v: fPos,
kind: Float64ValueKind,
pos: true,
zero: false,
neg: false,
vals: f64Values,
cmps: cmpsForPos,
},
}
for _, tt := range testcases {
if got := tt.v.IsPositive(tt.kind); got != tt.pos {
t.Errorf("Value %#v (%s) positive check failed, expected %v, got %v", tt.v, tt.v.Emit(tt.kind), tt.pos, got)
}
if got := tt.v.IsZero(tt.kind); got != tt.zero {
t.Errorf("Value %#v (%s) zero check failed, expected %v, got %v", tt.v, tt.v.Emit(tt.kind), tt.pos, got)
}
if got := tt.v.IsNegative(tt.kind); got != tt.neg {
t.Errorf("Value %#v (%s) negative check failed, expected %v, got %v", tt.v, tt.v.Emit(tt.kind), tt.pos, got)
}
for i := 0; i < 3; i++ {
if got := tt.v.RawCompare(tt.vals[i].AsRaw(), tt.kind); got != tt.cmps[i] {
t.Errorf("Value %#v (%s) compare check with %#v (%s) failed, expected %d, got %d", tt.v, tt.v.Emit(tt.kind), tt.vals[i], tt.vals[i].Emit(tt.kind), tt.cmps[i], got)
}
}
}
}

106
api/stats/stats.go
View File

@ -1,106 +0,0 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package stats
import (
"context"
"sync/atomic"
"go.opentelemetry.io/api/core"
)
type MeasureHandle struct {
Name string
}
type Measure interface {
N() string
M(value float64) Measurement
}
type Measurement struct {
Measure Measure
Value float64
}
type Recorder interface {
// TODO: Note as in rfc 0001, allow raw Measures to have pre-defined labels:
GetMeasure(ctx context.Context, measure *MeasureHandle, labels ...core.KeyValue) Measure
Record(ctx context.Context, m ...Measurement)
RecordSingle(ctx context.Context, m Measurement)
}
type noopRecorder struct{}
type noopMeasure struct{}
var global atomic.Value
// GlobalRecorder return meter registered with global registry.
// If no meter is registered then an instance of noop Recorder is returned.
func GlobalRecorder() Recorder {
if t := global.Load(); t != nil {
return t.(Recorder)
}
return noopRecorder{}
}
// SetGlobalRecorder sets provided meter as a global meter.
func SetGlobalRecorder(t Recorder) {
global.Store(t)
}
func Record(ctx context.Context, m ...Measurement) {
GlobalRecorder().Record(ctx, m...)
}
func RecordSingle(ctx context.Context, m Measurement) {
GlobalRecorder().RecordSingle(ctx, m)
}
func NewMeasure(name string) *MeasureHandle {
return &MeasureHandle{
Name: name,
}
}
func (m *MeasureHandle) M(value float64) Measurement {
return Measurement{
Measure: m,
Value: value,
}
}
func (m *MeasureHandle) N() string {
return m.Name
}
func (noopRecorder) Record(ctx context.Context, m ...Measurement) {
}
func (noopRecorder) RecordSingle(ctx context.Context, m Measurement) {
}
func (noopRecorder) GetMeasure(ctx context.Context, handle *MeasureHandle, labels ...core.KeyValue) Measure {
return noopMeasure{}
}
func (noopMeasure) M(float64) Measurement {
return Measurement{}
}
func (noopMeasure) N() string {
return ""
}

25
example/basic/main.go
View File

@ -19,7 +19,6 @@ import (
"go.opentelemetry.io/api/key"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/api/stats"
"go.opentelemetry.io/api/tag"
"go.opentelemetry.io/api/trace"
)
@ -39,7 +38,7 @@ var (
metric.WithDescription("A gauge set to 1.0"),
)
measureTwo = stats.NewMeasure("ex.com/two")
measureTwo = metric.NewFloat64Measure("ex.com/two")
)
func main() {
@ -50,11 +49,11 @@ func main() {
tag.Insert(barKey.String("bar1")),
)
gauge := meter.GetFloat64Gauge(
ctx,
oneMetric,
lemonsKey.Int(10),
)
commonLabels := meter.DefineLabels(ctx, lemonsKey.Int(10))
gauge := oneMetric.GetHandle(commonLabels)
measure := measureTwo.GetHandle(commonLabels)
err := tracer.WithSpan(ctx, "operation", func(ctx context.Context) error {
@ -64,6 +63,16 @@ func main() {
gauge.Set(ctx, 1)
meter.RecordBatch(
// Note: call-site variables added as context tags:
tag.NewContext(ctx,
tag.Insert(anotherKey.String("xyz"))),
commonLabels,
oneMetric.Measurement(1.0),
measureTwo.Measurement(2.0),
)
return tracer.WithSpan(
ctx,
"Sub operation...",
@ -72,7 +81,7 @@ func main() {
trace.CurrentSpan(ctx).AddEvent(ctx, "Sub span event")
stats.Record(ctx, measureTwo.M(1.3))
measure.Record(ctx, 1.3)
return nil
},

32
experimental/streaming/example/basic/main.go
View File

@ -19,7 +19,6 @@ import (
"go.opentelemetry.io/api/key"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/api/stats"
"go.opentelemetry.io/api/tag"
"go.opentelemetry.io/api/trace"
@ -28,10 +27,9 @@ import (
)
var (
streaming = sdk.New(spanlog.New())
tracer trace.Tracer = streaming
meter metric.Meter = metric.NoopMeter{}
streaming = sdk.New(spanlog.New())
tracer trace.Tracer = streaming
meter metric.Meter = streaming
fooKey = key.New("ex.com/foo")
barKey = key.New("ex.com/bar")
@ -43,7 +41,7 @@ var (
metric.WithDescription("A gauge set to 1.0"),
)
measureTwo = stats.NewMeasure("ex.com/two")
measureTwo = metric.NewFloat64Measure("ex.com/two")
)
func main() {
@ -54,11 +52,11 @@ func main() {
tag.Insert(barKey.String("bar1")),
)
gauge := meter.GetFloat64Gauge(
ctx,
oneMetric,
lemonsKey.Int(10),
)
commonLabels := meter.DefineLabels(ctx, lemonsKey.Int(10))
gauge := oneMetric.GetHandle(commonLabels)
measure := measureTwo.GetHandle(commonLabels)
err := tracer.WithSpan(ctx, "operation", func(ctx context.Context) error {
@ -68,6 +66,16 @@ func main() {
gauge.Set(ctx, 1)
meter.RecordBatch(
// Note: call-site variables added as context tags:
tag.NewContext(ctx,
tag.Insert(anotherKey.String("xyz"))),
commonLabels,
oneMetric.Measurement(1.0),
measureTwo.Measurement(2.0),
)
return tracer.WithSpan(
ctx,
"Sub operation...",
@ -76,7 +84,7 @@ func main() {
trace.CurrentSpan(ctx).AddEvent(ctx, "Sub span event")
stats.Record(ctx, measureTwo.M(1.3))
measure.Record(ctx, 1.3)
return nil
},

15
experimental/streaming/exporter/eventtype_string.go
View File

@ -13,17 +13,16 @@ func _() {
_ = x[END_SPAN-2]
_ = x[ADD_EVENT-3]
_ = x[NEW_SCOPE-4]
_ = x[NEW_MEASURE-5]
_ = x[NEW_METRIC-6]
_ = x[MODIFY_ATTR-7]
_ = x[RECORD_STATS-8]
_ = x[SET_STATUS-9]
_ = x[SET_NAME-10]
_ = x[MODIFY_ATTR-5]
_ = x[SET_STATUS-6]
_ = x[SET_NAME-7]
_ = x[SINGLE_METRIC-8]
_ = x[BATCH_METRIC-9]
}
const _EventType_name = "INVALIDSTART_SPANEND_SPANADD_EVENTNEW_SCOPENEW_MEASURENEW_METRICMODIFY_ATTRRECORD_STATSSET_STATUSSET_NAME"
const _EventType_name = "INVALIDSTART_SPANEND_SPANADD_EVENTNEW_SCOPEMODIFY_ATTRSET_STATUSSET_NAMESINGLE_METRICBATCH_METRIC"
var _EventType_index = [...]uint8{0, 7, 17, 25, 34, 43, 54, 64, 75, 87, 97, 105}
var _EventType_index = [...]uint8{0, 7, 17, 25, 34, 43, 54, 64, 72, 85, 97}
func (i EventType) String() string {
if i < 0 || i >= EventType(len(_EventType_index)-1) {

19
experimental/streaming/exporter/exporter.go
View File

@ -8,7 +8,7 @@ import (
"google.golang.org/grpc/codes"
"go.opentelemetry.io/api/core"
"go.opentelemetry.io/api/stats"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/api/tag"
)
@ -40,11 +40,10 @@ type Event struct {
Status codes.Code // SET_STATUS
// Values
String string // START_SPAN, EVENT, SET_NAME, ...
Float64 float64
Parent ScopeID // START_SPAN
Stats []stats.Measurement
Stat stats.Measurement
String string // START_SPAN, EVENT, SET_NAME, ...
Parent ScopeID // START_SPAN
Measurement metric.Measurement
Measurements []metric.Measurement
}
type Observer interface {
@ -58,12 +57,11 @@ const (
END_SPAN
ADD_EVENT
NEW_SCOPE
NEW_MEASURE
NEW_METRIC
MODIFY_ATTR
RECORD_STATS
SET_STATUS
SET_NAME
SINGLE_METRIC // A metric Set(), Add(), Record()
BATCH_METRIC // A RecordBatch()
)
type Exporter struct {
@ -101,6 +99,9 @@ func (e *Exporter) Foreach(f func(Observer)) {
}
func (e *Exporter) NewScope(parent ScopeID, attributes ...core.KeyValue) ScopeID {
if len(attributes) == 0 {
return parent
}
eventID := e.Record(Event{
Type: NEW_SCOPE,
Scope: parent,

54
experimental/streaming/exporter/reader/format/format.go
View File

@ -20,6 +20,8 @@ import (
"go.opentelemetry.io/api/core"
"go.opentelemetry.io/api/key"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/api/tag"
"go.opentelemetry.io/experimental/streaming/exporter"
"go.opentelemetry.io/experimental/streaming/exporter/reader"
@ -89,27 +91,17 @@ func AppendEvent(buf *strings.Builder, data reader.Event) {
case exporter.MODIFY_ATTR:
buf.WriteString("modify attr ")
buf.WriteString(data.Type.String())
case exporter.RECORD_STATS:
buf.WriteString("record")
for _, s := range data.Stats {
f(false)(core.Key{
Name: s.Measure.N(),
}.Float64(s.Value))
case exporter.SINGLE_METRIC:
formatMetricUpdate(buf, data.Measurement)
formatMetricLabels(buf, data.Attributes)
buf.WriteString(" {")
i := 0
s.Tags.Foreach(func(kv core.KeyValue) bool {
if i != 0 {
buf.WriteString(",")
}
i++
buf.WriteString(kv.Key.Name)
buf.WriteString("=")
buf.WriteString(kv.Value.Emit())
return true
})
buf.WriteString("}")
case exporter.BATCH_METRIC:
buf.WriteString("BATCH")
formatMetricLabels(buf, data.Attributes)
for _, m := range data.Measurements {
formatMetricUpdate(buf, m)
buf.WriteString(" ")
}
case exporter.SET_STATUS:
@ -142,6 +134,30 @@ func AppendEvent(buf *strings.Builder, data reader.Event) {
buf.WriteString(" ]\n")
}
func formatMetricUpdate(buf *strings.Builder, m metric.Measurement) {
buf.WriteString(m.Descriptor.Kind().String())
buf.WriteString(" ")
buf.WriteString(m.Descriptor.Name())
buf.WriteString("=")
buf.WriteString(m.Value.Emit(m.Descriptor.ValueKind()))
}
func formatMetricLabels(buf *strings.Builder, l tag.Map) {
buf.WriteString(" {")
i := 0
l.Foreach(func(kv core.KeyValue) bool {
if i != 0 {
buf.WriteString(",")
}
i++
buf.WriteString(kv.Key.Name)
buf.WriteString("=")
buf.WriteString(kv.Value.Emit())
return true
})
buf.WriteString("}")
}
func EventToString(data reader.Event) string {
var buf strings.Builder
AppendEvent(&buf, data)

104
experimental/streaming/exporter/reader/reader.go
View File

@ -22,8 +22,9 @@ import (
"google.golang.org/grpc/codes"
"go.opentelemetry.io/api/core"
"go.opentelemetry.io/api/stats"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/api/tag"
"go.opentelemetry.io/api/trace"
"go.opentelemetry.io/experimental/streaming/exporter"
)
@ -32,13 +33,14 @@ type Reader interface {
}
type Event struct {
Type exporter.EventType
Time time.Time
Sequence exporter.EventID
SpanContext core.SpanContext
Tags tag.Map
Attributes tag.Map
Stats []Measurement
Type exporter.EventType
Time time.Time
Sequence exporter.EventID
SpanContext core.SpanContext
Tags tag.Map // context tags
Attributes tag.Map // span attributes, metric labels
Measurement metric.Measurement
Measurements []metric.Measurement
Parent core.SpanContext
ParentAttributes tag.Map
@ -49,23 +51,11 @@ type Event struct {
Status codes.Code
}
type Measurement struct {
Measure stats.Measure
Value float64
Tags tag.Map
}
type readerObserver struct {
readers []Reader
// core.EventID -> *readerSpan or *readerScope
scopes sync.Map
// core.EventID -> *readerMeasure
measures sync.Map
// core.EventID -> *readerMetric
metrics sync.Map
}
type readerSpan struct {
@ -78,14 +68,6 @@ type readerSpan struct {
*readerScope
}
type readerMeasure struct {
name string
}
type readerMetric struct {
*readerMeasure
}
type readerScope struct {
span *readerSpan
parent exporter.EventID
@ -222,24 +204,6 @@ func (ro *readerObserver) orderedObserve(event exporter.Event) {
read.Tags = span.startTags
}
case exporter.NEW_MEASURE:
measure := &readerMeasure{
name: event.String,
}
ro.measures.Store(event.Sequence, measure)
return
case exporter.NEW_METRIC:
measureI, has := ro.measures.Load(event.Scope.EventID)
if !has {
panic("metric measure not found")
}
metric := &readerMetric{
readerMeasure: measureI.(*readerMeasure),
}
ro.metrics.Store(event.Sequence, metric)
return
case exporter.ADD_EVENT:
read.Type = exporter.ADD_EVENT
read.Message = event.String
@ -252,20 +216,34 @@ func (ro *readerObserver) orderedObserve(event exporter.Event) {
read.SpanContext = span.spanContext
}
case exporter.RECORD_STATS:
read.Type = exporter.RECORD_STATS
case exporter.SINGLE_METRIC:
read.Type = exporter.SINGLE_METRIC
_, span := ro.readScope(event.Scope)
if span != nil {
read.SpanContext = span.spanContext
if event.Context != nil {
span := trace.CurrentSpan(event.Context)
if span != nil {
read.SpanContext = span.SpanContext()
}
}
for _, es := range event.Stats {
ro.addMeasurement(&read, es)
}
if event.Stat.Measure != nil {
ro.addMeasurement(&read, event.Stat)
attrs, _ := ro.readScope(event.Scope)
read.Attributes = attrs
read.Measurement = event.Measurement
case exporter.BATCH_METRIC:
read.Type = event.Type
if event.Context != nil {
span := trace.CurrentSpan(event.Context)
if span != nil {
read.SpanContext = span.SpanContext()
}
}
attrs, _ := ro.readScope(event.Scope)
read.Attributes = attrs
read.Measurements = make([]metric.Measurement, len(event.Measurements))
copy(read.Measurements, event.Measurements)
case exporter.SET_STATUS:
read.Type = exporter.SET_STATUS
read.Status = event.Status
@ -292,20 +270,6 @@ func (ro *readerObserver) orderedObserve(event exporter.Event) {
}
}
func (ro *readerObserver) addMeasurement(e *Event, m stats.Measurement) {
attrs, _ := ro.readMeasureScope(m.Measure)
e.Stats = append(e.Stats, Measurement{
Measure: m.Measure,
Value: m.Value,
Tags: attrs,
})
}
func (ro *readerObserver) readMeasureScope(m stats.Measure) (tag.Map, *readerSpan) {
// TODO
return tag.NewEmptyMap(), nil
}
func (ro *readerObserver) readScope(id exporter.ScopeID) (tag.Map, *readerSpan) {
if id.EventID == 0 {
return tag.NewEmptyMap(), nil

45
experimental/streaming/exporter/spandata/spandata.go
View File

@ -25,7 +25,8 @@ type Reader interface {
}
type Span struct {
Events []reader.Event
Events []reader.Event
Aggregates map[string]float64
}
type spanReader struct {
@ -41,27 +42,37 @@ func NewReaderObserver(readers ...Reader) exporter.Observer {
}
func (s *spanReader) Read(data reader.Event) {
if !data.SpanContext.HasSpanID() {
panic("How is this?")
}
var span *Span
if data.Type == exporter.START_SPAN {
span = &Span{Events: make([]reader.Event, 0, 4)}
s.spans[data.SpanContext] = span
} else {
span = s.spans[data.SpanContext]
if span == nil {
// TODO count and report this.
return
if data.SpanContext.HasSpanID() {
if data.Type == exporter.START_SPAN {
span = &Span{Events: make([]reader.Event, 0, 4)}
s.spans[data.SpanContext] = span
} else {
span = s.spans[data.SpanContext]
if span == nil {
// TODO count and report this.
return
}
}
}
span.Events = append(span.Events, data)
switch data.Type {
case exporter.SINGLE_METRIC:
s.updateMetric(data)
return
}
if data.Type == exporter.END_SPAN {
for _, r := range s.readers {
r.Read(span)
if span != nil {
span.Events = append(span.Events, data)
if data.Type == exporter.END_SPAN {
for _, r := range s.readers {
r.Read(span)
}
delete(s.spans, data.SpanContext)
}
delete(s.spans, data.SpanContext)
}
}
func (s *spanReader) updateMetric(data reader.Event) {
// TODO aggregate
}

175
experimental/streaming/sdk/metric.go Normal file
View File

@ -0,0 +1,175 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package sdk
import (
"context"
"time"
"go.opentelemetry.io/api/core"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/experimental/streaming/exporter"
)
type metricHandle struct {
descriptor *metric.Descriptor
labels metricLabels
}
var _ metric.Handle = &metricHandle{}
type metricLabels struct {
sdk *sdk
scope exporter.ScopeID
}
var _ metric.LabelSet = &metricLabels{}
func (h *metricHandle) RecordOne(ctx context.Context, value metric.MeasurementValue) {
h.labels.sdk.exporter.Record(exporter.Event{
Type: exporter.SINGLE_METRIC,
Context: ctx,
Scope: h.labels.scope,
Measurement: metric.Measurement{
Descriptor: h.descriptor,
Value: value,
},
})
}
func (m metricLabels) Meter() metric.Meter {
return m.sdk
}
func (s *sdk) DefineLabels(ctx context.Context, labels ...core.KeyValue) metric.LabelSet {
return metricLabels{
sdk: s,
scope: s.exporter.NewScope(exporter.ScopeID{}, labels...),
}
}
func (s *sdk) NewHandle(descriptor *metric.Descriptor, labels metric.LabelSet) metric.Handle {
mlabels, _ := labels.(metricLabels)
return &metricHandle{
descriptor: descriptor,
labels: mlabels,
}
}
func (s *sdk) DeleteHandle(handle metric.Handle) {
}
func (s *sdk) RecordBatch(ctx context.Context, labels metric.LabelSet, ms ...metric.Measurement) {
eventType := exporter.BATCH_METRIC
if len(ms) == 1 {
eventType = exporter.SINGLE_METRIC
}
oms := make([]metric.Measurement, len(ms))
mlabels, _ := labels.(metricLabels)
copy(oms, ms)
s.exporter.Record(exporter.Event{
Type: eventType,
Context: ctx,
Scope: mlabels.scope,
Measurements: oms,
})
}
func (s *sdk) RegisterObserver(observer metric.Observer, callback metric.ObserverCallback) {
if s.insertNewObserver(observer, callback) {
go s.observersRoutine()
}
}
func (s *sdk) insertNewObserver(observer metric.Observer, callback metric.ObserverCallback) bool {
s.observersLock.Lock()
defer s.observersLock.Unlock()
old := s.loadObserversMap()
id := observer.Descriptor.ID()
if _, ok := old[id]; ok {
return false
}
observers := make(observersMap)
for oid, data := range old {
observers[oid] = data
}
observers[id] = observerData{
observer: observer,
callback: callback,
}
s.storeObserversMap(observers)
return old == nil
}
func (s *sdk) UnregisterObserver(observer metric.Observer) {
s.observersLock.Lock()
defer s.observersLock.Unlock()
old := s.loadObserversMap()
id := observer.Descriptor.ID()
if _, ok := old[id]; !ok {
return
}
if len(old) == 1 {
s.storeObserversMap(nil)
return
}
observers := make(observersMap)
for oid, data := range old {
if oid != id {
observers[oid] = data
}
}
s.storeObserversMap(observers)
}
func (s *sdk) observersRoutine() {
ticker := time.NewTicker(time.Second)
defer ticker.Stop()
for range ticker.C {
m := s.loadObserversMap()
if m == nil {
return
}
for _, data := range m {
ocb := s.getObservationCallback(data.observer.Descriptor)
data.callback(s, data.observer, ocb)
}
}
}
func (s *sdk) getObservationCallback(descriptor *metric.Descriptor) metric.ObservationCallback {
return func(l metric.LabelSet, v metric.MeasurementValue) {
s.RecordBatch(context.Background(), l, metric.Measurement{
Descriptor: descriptor,
Value: v,
})
}
}
func (s *sdk) loadObserversMap() observersMap {
i := s.observers.Load()
if i == nil {
return nil
}
m := i.(observersMap)
return m
}
func (s *sdk) storeObserversMap(m observersMap) {
s.observers.Store(m)
}

52
experimental/streaming/sdk/package.go Normal file
View File

@ -0,0 +1,52 @@
// Copyright 2019, OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package sdk
import (
"sync"
"sync/atomic"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/api/trace"
"go.opentelemetry.io/experimental/streaming/exporter"
)
type observerData struct {
observer metric.Observer
callback metric.ObserverCallback
}
type observersMap map[metric.DescriptorID]observerData
type sdk struct {
exporter *exporter.Exporter
resources exporter.EventID
observersLock sync.Mutex
observers atomic.Value // observersMap
}
type SDK interface {
trace.Tracer
metric.Meter
}
var _ SDK = &sdk{}
func New(observers ...exporter.Observer) SDK {
return &sdk{
exporter: exporter.NewExporter(observers...),
}
}

20
experimental/streaming/sdk/span.go
View File

@ -27,7 +27,7 @@ import (
)
type span struct {
tracer *tracer
sdk *sdk
initial exporter.ScopeID
}
@ -44,7 +44,7 @@ func (sp *span) IsRecordingEvents() bool {
// SetStatus sets the status of the span.
func (sp *span) SetStatus(status codes.Code) {
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Type: exporter.SET_STATUS,
Scope: sp.ScopeID(),
Status: status,
@ -56,7 +56,7 @@ func (sp *span) ScopeID() exporter.ScopeID {
}
func (sp *span) SetAttribute(attribute core.KeyValue) {
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Type: exporter.MODIFY_ATTR,
Scope: sp.ScopeID(),
Attribute: attribute,
@ -64,7 +64,7 @@ func (sp *span) SetAttribute(attribute core.KeyValue) {
}
func (sp *span) SetAttributes(attributes ...core.KeyValue) {
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Type: exporter.MODIFY_ATTR,
Scope: sp.ScopeID(),
Attributes: attributes,
@ -72,7 +72,7 @@ func (sp *span) SetAttributes(attributes ...core.KeyValue) {
}
func (sp *span) ModifyAttribute(mutator tag.Mutator) {
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Type: exporter.MODIFY_ATTR,
Scope: sp.ScopeID(),
Mutator: mutator,
@ -80,7 +80,7 @@ func (sp *span) ModifyAttribute(mutator tag.Mutator) {
}
func (sp *span) ModifyAttributes(mutators ...tag.Mutator) {
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Type: exporter.MODIFY_ATTR,
Scope: sp.ScopeID(),
Mutators: mutators,
@ -93,7 +93,7 @@ func (sp *span) End(options ...trace.EndOption) {
for _, opt := range options {
opt(&opts)
}
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Time: opts.EndTime,
Type: exporter.END_SPAN,
Scope: sp.ScopeID(),
@ -105,7 +105,7 @@ func (sp *span) End(options ...trace.EndOption) {
}
func (sp *span) Tracer() trace.Tracer {
return sp.tracer
return sp.sdk
}
func (sp *span) AddEvent(ctx context.Context, msg string, attrs ...core.KeyValue) {
@ -117,7 +117,7 @@ func (sp *span) AddEventWithTimestamp(ctx context.Context, timestamp time.Time,
}
func (sp *span) addEventWithTime(ctx context.Context, timestamp time.Time, msg string, attrs ...core.KeyValue) {
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Time: timestamp,
Type: exporter.ADD_EVENT,
Scope: sp.ScopeID(),
@ -128,7 +128,7 @@ func (sp *span) addEventWithTime(ctx context.Context, timestamp time.Time, msg s
}
func (sp *span) SetName(name string) {
sp.tracer.exporter.Record(exporter.Event{
sp.sdk.exporter.Record(exporter.Event{
Type: exporter.SET_NAME,
String: name,
})

22
experimental/streaming/sdk/span_test.go
View File

@ -24,6 +24,7 @@ import (
"go.opentelemetry.io/api/core"
"go.opentelemetry.io/api/key"
"go.opentelemetry.io/api/metric"
"go.opentelemetry.io/api/trace"
"go.opentelemetry.io/experimental/streaming/exporter"
@ -130,6 +131,26 @@ func checkContext(t *testing.T, ctx context.Context, key, wantValue interface{})
return true
}
func measurementCompare(m1, m2 metric.Measurement) bool {
// Nil descriptor normally shouldn't happen, unless there is
// some struct with the Measurement field that didn't get
// initialized.
m1Nil := m1.Descriptor == nil
m2Nil := m2.Descriptor == nil
if m1Nil != m2Nil {
return false
}
if m1Nil {
return m1.Value.AsRaw() == m2.Value.AsRaw()
}
if m1.Descriptor.ID() != m2.Descriptor.ID() {
return false
}
m2Raw := m2.Value.AsRaw()
kind := m1.Descriptor.ValueKind()
return m1.Value.RawCompare(m2Raw, kind) == 0
}
func diffEvents(t *testing.T, got, want []exporter.Event, extraIgnoredFields ...string) bool {
ignoredPaths := map[string]struct{}{
"Sequence": struct{}{},
@ -143,6 +164,7 @@ func diffEvents(t *testing.T, got, want []exporter.Event, extraIgnoredFields ...
_, found := ignoredPaths[path.String()]
return found
}, cmp.Ignore()),
cmp.Comparer(measurementCompare),
}
if diff := cmp.Diff(got, want, opts...); diff != "" {
t.Errorf("Events: -got +want %s", diff)

27
experimental/streaming/sdk/trace.go
View File

@ -24,11 +24,6 @@ import (
"go.opentelemetry.io/experimental/streaming/exporter"
)
type tracer struct {
exporter *exporter.Exporter
resources exporter.EventID
}
var (
// TODO These should move somewhere in the api, right?
ErrorKey = key.New("error")
@ -37,16 +32,10 @@ var (
MessageKey = key.New("message")
)
func New(observers ...exporter.Observer) trace.Tracer {
return &tracer{
exporter: exporter.NewExporter(observers...),
}
}
func (t *tracer) WithSpan(ctx context.Context, name string, body func(context.Context) error) error {
// TODO: use runtime/trace.WithRegion for execution tracer support
func (s *sdk) WithSpan(ctx context.Context, name string, body func(context.Context) error) error {
// TODO: use runtime/trace.WithRegion for execution sdk support
// TODO: use runtime/pprof.Do for profile tags support
ctx, span := t.Start(ctx, name)
ctx, span := s.Start(ctx, name)
defer span.End()
if err := body(ctx); err != nil {
@ -57,7 +46,7 @@ func (t *tracer) WithSpan(ctx context.Context, name string, body func(context.Co
return nil
}
func (t *tracer) Start(ctx context.Context, name string, opts ...trace.SpanOption) (context.Context, trace.Span) {
func (s *sdk) Start(ctx context.Context, name string, opts ...trace.SpanOption) (context.Context, trace.Span) {
var child core.SpanContext
child.SpanID = rand.Uint64()
@ -87,17 +76,17 @@ func (t *tracer) Start(ctx context.Context, name string, opts ...trace.SpanOptio
childScope := exporter.ScopeID{
SpanContext: child,
EventID: t.resources,
EventID: s.resources,
}
span := &span{
tracer: t,
sdk: s,
initial: exporter.ScopeID{
SpanContext: child,
EventID: t.exporter.Record(exporter.Event{
EventID: s.exporter.Record(exporter.Event{
Time: o.StartTime,
Type: exporter.START_SPAN,
Scope: t.exporter.NewScope(childScope, o.Attributes...),
Scope: s.exporter.NewScope(childScope, o.Attributes...),
Context: ctx,
Parent: parentScope,
String: name,