go/internal/telemetry/event/key.go

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package event

var (
	// Err is a key used to add error values to tag lists.
	Err = NewErrorKey("error", "")
)

// Key is the interface shared by all key implementations.
type Key interface {
	// Identity returns the underlying key identity.
	Identity() interface{}
	// Name returns the key name.
	Name() string
	// Description returns a string that can be used to describe the value.
	Description() string
	// OfValue creates a new Tag with this key and the supplied untyped value.
	OfValue(interface{}) Tag
}

// key is used as the identity of a Tag.
// Keys are intended to be compared by pointer only, the name should be unique
// for communicating with external systems, but it is not required or enforced.
type key struct {
	name        string
	description string
}

func newKey(name, description string) *key   { return &key{name: name, description: description} }
func (k *key) Name() string                  { return k.name }
func (k *key) Description() string           { return k.description }
func (k *key) Identity() interface{}         { return k }
func (k *key) OfValue(value interface{}) Tag { return Tag{key: k, value: value} }

// ValueKey represents a key for untyped values.
type ValueKey struct{ *key }

// NewKey creates a new Key for untyped values.
func NewKey(name, description string) ValueKey {
	return ValueKey{newKey(name, description)}
}

// Get can be used to get a tag for the key from a TagList.
func (k ValueKey) Get(tags TagSet) interface{} {
	if t := tags.find(k.key); t.key != nil {
		return t.value
	}
	return nil
}

// Of creates a new Tag with this key and the supplied value.
func (k ValueKey) Of(value interface{}) Tag { return Tag{key: k.key, value: value} }

// IntKey represents a key
type IntKey struct{ *key }

// NewIntKey creates a new Key for int values.
func NewIntKey(name, description string) IntKey {
	return IntKey{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k IntKey) Of(v int) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k IntKey) Get(tags TagSet) int {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(int)
	}
	return 0
}

// Int8Key represents a key
type Int8Key struct{ *key }

// NewInt8Key creates a new Key for int8 values.
func NewInt8Key(name, description string) Int8Key {
	return Int8Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k Int8Key) Of(v int8) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k Int8Key) Get(tags TagSet) int8 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(int8)
	}
	return 0
}

// Int16Key represents a key
type Int16Key struct{ *key }

// NewInt16Key creates a new Key for int16 values.
func NewInt16Key(name, description string) Int16Key {
	return Int16Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k Int16Key) Of(v int16) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k Int16Key) Get(tags TagSet) int16 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(int16)
	}
	return 0
}

// Int32Key represents a key
type Int32Key struct{ *key }

// NewInt32Key creates a new Key for int32 values.
func NewInt32Key(name, description string) Int32Key {
	return Int32Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k Int32Key) Of(v int32) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k Int32Key) Get(tags TagSet) int32 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(int32)
	}
	return 0
}

// Int64Key represents a key
type Int64Key struct{ *key }

// NewInt64Key creates a new Key for int64 values.
func NewInt64Key(name, description string) Int64Key {
	return Int64Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k Int64Key) Of(v int64) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k Int64Key) Get(tags TagSet) int64 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(int64)
	}
	return 0
}

// UIntKey represents a key
type UIntKey struct{ *key }

// NewUIntKey creates a new Key for uint values.
func NewUIntKey(name, description string) UIntKey {
	return UIntKey{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k UIntKey) Of(v uint) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k UIntKey) Get(tags TagSet) uint {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(uint)
	}
	return 0
}

// UInt8Key represents a key
type UInt8Key struct{ *key }

// NewUInt8Key creates a new Key for uint8 values.
func NewUInt8Key(name, description string) UInt8Key {
	return UInt8Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k UInt8Key) Of(v uint8) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k UInt8Key) Get(tags TagSet) uint8 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(uint8)
	}
	return 0
}

// UInt16Key represents a key
type UInt16Key struct{ *key }

// NewUInt16Key creates a new Key for uint16 values.
func NewUInt16Key(name, description string) UInt16Key {
	return UInt16Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k UInt16Key) Of(v uint16) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k UInt16Key) Get(tags TagSet) uint16 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(uint16)
	}
	return 0
}

// UInt32Key represents a key
type UInt32Key struct{ *key }

// NewUInt32Key creates a new Key for uint32 values.
func NewUInt32Key(name, description string) UInt32Key {
	return UInt32Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k UInt32Key) Of(v uint32) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k UInt32Key) Get(tags TagSet) uint32 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(uint32)
	}
	return 0
}

// UInt64Key represents a key
type UInt64Key struct{ *key }

// NewUInt64Key creates a new Key for uint64 values.
func NewUInt64Key(name, description string) UInt64Key {
	return UInt64Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k UInt64Key) Of(v uint64) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k UInt64Key) Get(tags TagSet) uint64 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(uint64)
	}
	return 0
}

// Float32Key represents a key
type Float32Key struct{ *key }

// NewFloat32Key creates a new Key for float32 values.
func NewFloat32Key(name, description string) Float32Key {
	return Float32Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k Float32Key) Of(v float32) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k Float32Key) Get(tags TagSet) float32 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(float32)
	}
	return 0
}

// Float64Key represents a key
type Float64Key struct{ *key }

// NewFloat64Key creates a new Key for int64 values.
func NewFloat64Key(name, description string) Float64Key {
	return Float64Key{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k Float64Key) Of(v float64) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k Float64Key) Get(tags TagSet) float64 {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(float64)
	}
	return 0
}

// StringKey represents a key
type StringKey struct{ *key }

// NewStringKey creates a new Key for int64 values.
func NewStringKey(name, description string) StringKey {
	return StringKey{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k StringKey) Of(v string) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k StringKey) Get(tags TagSet) string {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(string)
	}
	return ""
}

// BooleanKey represents a key
type BooleanKey struct{ *key }

// NewBooleanKey creates a new Key for bool values.
func NewBooleanKey(name, description string) BooleanKey {
	return BooleanKey{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k BooleanKey) Of(v bool) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k BooleanKey) Get(tags TagSet) bool {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(bool)
	}
	return false
}

// ErrorKey represents a key
type ErrorKey struct{ *key }

// NewErrorKey creates a new Key for int64 values.
func NewErrorKey(name, description string) ErrorKey {
	return ErrorKey{newKey(name, description)}
}

// Of creates a new Tag with this key and the supplied value.
func (k ErrorKey) Of(v error) Tag { return Tag{key: k.key, value: v} }

// Get can be used to get a tag for the key from a TagSet.
func (k ErrorKey) Get(tags TagSet) error {
	if t := tags.find(k.key); t.key != nil {
		return t.value.(error)
	}
	return nil
}