--- /dev/null
+// 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
+
+import (
+ "fmt"
+ "io"
+ "math"
+ "strconv"
+)
+
+var (
+ // Msg is a key used to add message strings to tag lists.
+ Msg = NewStringKey("message", "a readable message")
+ // Name is used for things like traces that have a name.
+ Name = NewStringKey("name", "an entity name")
+ // Err is a key used to add error values to tag lists.
+ Err = NewErrorKey("error", "an error that occurred")
+)
+
+// 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 interface {
+ // Name returns the key name.
+ Name() string
+ // Description returns a string that can be used to describe the value.
+ Description() string
+
+ // Format is used in formatting to append the value of the tag to the
+ // supplied buffer.
+ // The formatter may use the supplied buf as a scratch area to avoid
+ // allocations.
+ Format(w io.Writer, buf []byte, tag Tag)
+}
+
+// ValueKey represents a key for untyped values.
+type ValueKey struct {
+ name string
+ description string
+}
+
+// NewKey creates a new Key for untyped values.
+func NewKey(name, description string) *ValueKey {
+ return &ValueKey{name: name, description: description}
+}
+
+func (k *ValueKey) Name() string { return k.name }
+func (k *ValueKey) Description() string { return k.description }
+
+func (k *ValueKey) Format(w io.Writer, buf []byte, tag Tag) {
+ fmt.Fprint(w, k.From(tag))
+}
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *ValueKey) Get(tags TagMap) interface{} {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return nil
+}
+
+// From can be used to get a value from a Tag.
+func (k *ValueKey) From(t Tag) interface{} { return t.UnpackValue() }
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *ValueKey) Of(value interface{}) Tag { return TagOfValue(k, value) }
+
+// IntKey represents a key
+type IntKey struct {
+ name string
+ description string
+}
+
+// NewIntKey creates a new Key for int values.
+func NewIntKey(name, description string) *IntKey {
+ return &IntKey{name: name, description: description}
+}
+
+func (k *IntKey) Name() string { return k.name }
+func (k *IntKey) Description() string { return k.description }
+
+func (k *IntKey) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *IntKey) Of(v int) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *IntKey) Get(tags TagMap) int {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *IntKey) From(t Tag) int { return int(t.Unpack64()) }
+
+// Int8Key represents a key
+type Int8Key struct {
+ name string
+ description string
+}
+
+// NewInt8Key creates a new Key for int8 values.
+func NewInt8Key(name, description string) *Int8Key {
+ return &Int8Key{name: name, description: description}
+}
+
+func (k *Int8Key) Name() string { return k.name }
+func (k *Int8Key) Description() string { return k.description }
+
+func (k *Int8Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *Int8Key) Of(v int8) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *Int8Key) Get(tags TagMap) int8 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *Int8Key) From(t Tag) int8 { return int8(t.Unpack64()) }
+
+// Int16Key represents a key
+type Int16Key struct {
+ name string
+ description string
+}
+
+// NewInt16Key creates a new Key for int16 values.
+func NewInt16Key(name, description string) *Int16Key {
+ return &Int16Key{name: name, description: description}
+}
+
+func (k *Int16Key) Name() string { return k.name }
+func (k *Int16Key) Description() string { return k.description }
+
+func (k *Int16Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *Int16Key) Of(v int16) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *Int16Key) Get(tags TagMap) int16 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *Int16Key) From(t Tag) int16 { return int16(t.Unpack64()) }
+
+// Int32Key represents a key
+type Int32Key struct {
+ name string
+ description string
+}
+
+// NewInt32Key creates a new Key for int32 values.
+func NewInt32Key(name, description string) *Int32Key {
+ return &Int32Key{name: name, description: description}
+}
+
+func (k *Int32Key) Name() string { return k.name }
+func (k *Int32Key) Description() string { return k.description }
+
+func (k *Int32Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendInt(buf, int64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *Int32Key) Of(v int32) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *Int32Key) Get(tags TagMap) int32 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *Int32Key) From(t Tag) int32 { return int32(t.Unpack64()) }
+
+// Int64Key represents a key
+type Int64Key struct {
+ name string
+ description string
+}
+
+// NewInt64Key creates a new Key for int64 values.
+func NewInt64Key(name, description string) *Int64Key {
+ return &Int64Key{name: name, description: description}
+}
+
+func (k *Int64Key) Name() string { return k.name }
+func (k *Int64Key) Description() string { return k.description }
+
+func (k *Int64Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendInt(buf, k.From(tag), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *Int64Key) Of(v int64) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *Int64Key) Get(tags TagMap) int64 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *Int64Key) From(t Tag) int64 { return int64(t.Unpack64()) }
+
+// UIntKey represents a key
+type UIntKey struct {
+ name string
+ description string
+}
+
+// NewUIntKey creates a new Key for uint values.
+func NewUIntKey(name, description string) *UIntKey {
+ return &UIntKey{name: name, description: description}
+}
+
+func (k *UIntKey) Name() string { return k.name }
+func (k *UIntKey) Description() string { return k.description }
+
+func (k *UIntKey) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *UIntKey) Of(v uint) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *UIntKey) Get(tags TagMap) uint {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *UIntKey) From(t Tag) uint { return uint(t.Unpack64()) }
+
+// UInt8Key represents a key
+type UInt8Key struct {
+ name string
+ description string
+}
+
+// NewUInt8Key creates a new Key for uint8 values.
+func NewUInt8Key(name, description string) *UInt8Key {
+ return &UInt8Key{name: name, description: description}
+}
+
+func (k *UInt8Key) Name() string { return k.name }
+func (k *UInt8Key) Description() string { return k.description }
+
+func (k *UInt8Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *UInt8Key) Of(v uint8) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *UInt8Key) Get(tags TagMap) uint8 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *UInt8Key) From(t Tag) uint8 { return uint8(t.Unpack64()) }
+
+// UInt16Key represents a key
+type UInt16Key struct {
+ name string
+ description string
+}
+
+// NewUInt16Key creates a new Key for uint16 values.
+func NewUInt16Key(name, description string) *UInt16Key {
+ return &UInt16Key{name: name, description: description}
+}
+
+func (k *UInt16Key) Name() string { return k.name }
+func (k *UInt16Key) Description() string { return k.description }
+
+func (k *UInt16Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *UInt16Key) Of(v uint16) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *UInt16Key) Get(tags TagMap) uint16 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *UInt16Key) From(t Tag) uint16 { return uint16(t.Unpack64()) }
+
+// UInt32Key represents a key
+type UInt32Key struct {
+ name string
+ description string
+}
+
+// NewUInt32Key creates a new Key for uint32 values.
+func NewUInt32Key(name, description string) *UInt32Key {
+ return &UInt32Key{name: name, description: description}
+}
+
+func (k *UInt32Key) Name() string { return k.name }
+func (k *UInt32Key) Description() string { return k.description }
+
+func (k *UInt32Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendUint(buf, uint64(k.From(tag)), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *UInt32Key) Of(v uint32) Tag { return TagOf64(k, uint64(v)) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *UInt32Key) Get(tags TagMap) uint32 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *UInt32Key) From(t Tag) uint32 { return uint32(t.Unpack64()) }
+
+// UInt64Key represents a key
+type UInt64Key struct {
+ name string
+ description string
+}
+
+// NewUInt64Key creates a new Key for uint64 values.
+func NewUInt64Key(name, description string) *UInt64Key {
+ return &UInt64Key{name: name, description: description}
+}
+
+func (k *UInt64Key) Name() string { return k.name }
+func (k *UInt64Key) Description() string { return k.description }
+
+func (k *UInt64Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendUint(buf, k.From(tag), 10))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *UInt64Key) Of(v uint64) Tag { return TagOf64(k, v) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *UInt64Key) Get(tags TagMap) uint64 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *UInt64Key) From(t Tag) uint64 { return t.Unpack64() }
+
+// Float32Key represents a key
+type Float32Key struct {
+ name string
+ description string
+}
+
+// NewFloat32Key creates a new Key for float32 values.
+func NewFloat32Key(name, description string) *Float32Key {
+ return &Float32Key{name: name, description: description}
+}
+
+func (k *Float32Key) Name() string { return k.name }
+func (k *Float32Key) Description() string { return k.description }
+
+func (k *Float32Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendFloat(buf, float64(k.From(tag)), 'E', -1, 32))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *Float32Key) Of(v float32) Tag {
+ return TagOf64(k, uint64(math.Float32bits(v)))
+}
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *Float32Key) Get(tags TagMap) float32 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *Float32Key) From(t Tag) float32 {
+ return math.Float32frombits(uint32(t.Unpack64()))
+}
+
+// Float64Key represents a key
+type Float64Key struct {
+ name string
+ description string
+}
+
+// NewFloat64Key creates a new Key for int64 values.
+func NewFloat64Key(name, description string) *Float64Key {
+ return &Float64Key{name: name, description: description}
+}
+
+func (k *Float64Key) Name() string { return k.name }
+func (k *Float64Key) Description() string { return k.description }
+
+func (k *Float64Key) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendFloat(buf, k.From(tag), 'E', -1, 64))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *Float64Key) Of(v float64) Tag {
+ return TagOf64(k, math.Float64bits(v))
+}
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *Float64Key) Get(tags TagMap) float64 {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return 0
+}
+
+// From can be used to get a value from a Tag.
+func (k *Float64Key) From(t Tag) float64 {
+ return math.Float64frombits(t.Unpack64())
+}
+
+// StringKey represents a key
+type StringKey struct {
+ name string
+ description string
+}
+
+// NewStringKey creates a new Key for int64 values.
+func NewStringKey(name, description string) *StringKey {
+ return &StringKey{name: name, description: description}
+}
+
+func (k *StringKey) Name() string { return k.name }
+func (k *StringKey) Description() string { return k.description }
+
+func (k *StringKey) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendQuote(buf, k.From(tag)))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *StringKey) Of(v string) Tag { return TagOfString(k, v) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *StringKey) Get(tags TagMap) string {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return ""
+}
+
+// From can be used to get a value from a Tag.
+func (k *StringKey) From(t Tag) string { return t.UnpackString() }
+
+// BooleanKey represents a key
+type BooleanKey struct {
+ name string
+ description string
+}
+
+// NewBooleanKey creates a new Key for bool values.
+func NewBooleanKey(name, description string) *BooleanKey {
+ return &BooleanKey{name: name, description: description}
+}
+
+func (k *BooleanKey) Name() string { return k.name }
+func (k *BooleanKey) Description() string { return k.description }
+
+func (k *BooleanKey) Format(w io.Writer, buf []byte, tag Tag) {
+ w.Write(strconv.AppendBool(buf, k.From(tag)))
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *BooleanKey) Of(v bool) Tag {
+ if v {
+ return TagOf64(k, 1)
+ }
+ return TagOf64(k, 0)
+}
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *BooleanKey) Get(tags TagMap) bool {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return false
+}
+
+// From can be used to get a value from a Tag.
+func (k *BooleanKey) From(t Tag) bool { return t.Unpack64() > 0 }
+
+// ErrorKey represents a key
+type ErrorKey struct {
+ name string
+ description string
+}
+
+// NewErrorKey creates a new Key for int64 values.
+func NewErrorKey(name, description string) *ErrorKey {
+ return &ErrorKey{name: name, description: description}
+}
+
+func (k *ErrorKey) Name() string { return k.name }
+func (k *ErrorKey) Description() string { return k.description }
+
+func (k *ErrorKey) Format(w io.Writer, buf []byte, tag Tag) {
+ io.WriteString(w, k.From(tag).Error())
+}
+
+// Of creates a new Tag with this key and the supplied value.
+func (k *ErrorKey) Of(v error) Tag { return TagOfValue(k, v) }
+
+// Get can be used to get a tag for the key from a TagMap.
+func (k *ErrorKey) Get(tags TagMap) error {
+ if t := tags.Find(k); t.Valid() {
+ return k.From(t)
+ }
+ return nil
+}
+
+// From can be used to get a value from a Tag.
+func (k *ErrorKey) From(t Tag) error {
+ err, _ := t.UnpackValue().(error)
+ return err
+}
projects / dotfiles / .git / blobdiff