blob: 7d7237809902aa50b7053eb2fcb0f1c0bde1de54 [file] [log] [blame]
Joey Armstrong903c69d2024-02-01 19:46:39 -05001// Copyright The OpenTelemetry Authors
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package label
16
17// Key represents the key part in key-value pairs. It's a string. The
18// allowed character set in the key depends on the use of the key.
19type Key string
20
21// Bool creates a KeyValue instance with a BOOL Value.
22//
23// If creating both key and a bool value at the same time, then
24// instead of calling Key(name).Bool(value) consider using a
25// convenience function provided by the api/key package -
26// key.Bool(name, value).
27func (k Key) Bool(v bool) KeyValue {
28 return KeyValue{
29 Key: k,
30 Value: BoolValue(v),
31 }
32}
33
34// Int64 creates a KeyValue instance with an INT64 Value.
35//
36// If creating both key and an int64 value at the same time, then
37// instead of calling Key(name).Int64(value) consider using a
38// convenience function provided by the api/key package -
39// key.Int64(name, value).
40func (k Key) Int64(v int64) KeyValue {
41 return KeyValue{
42 Key: k,
43 Value: Int64Value(v),
44 }
45}
46
47// Uint64 creates a KeyValue instance with a UINT64 Value.
48//
49// If creating both key and a uint64 value at the same time, then
50// instead of calling Key(name).Uint64(value) consider using a
51// convenience function provided by the api/key package -
52// key.Uint64(name, value).
53func (k Key) Uint64(v uint64) KeyValue {
54 return KeyValue{
55 Key: k,
56 Value: Uint64Value(v),
57 }
58}
59
60// Float64 creates a KeyValue instance with a FLOAT64 Value.
61//
62// If creating both key and a float64 value at the same time, then
63// instead of calling Key(name).Float64(value) consider using a
64// convenience function provided by the api/key package -
65// key.Float64(name, value).
66func (k Key) Float64(v float64) KeyValue {
67 return KeyValue{
68 Key: k,
69 Value: Float64Value(v),
70 }
71}
72
73// Int32 creates a KeyValue instance with an INT32 Value.
74//
75// If creating both key and an int32 value at the same time, then
76// instead of calling Key(name).Int32(value) consider using a
77// convenience function provided by the api/key package -
78// key.Int32(name, value).
79func (k Key) Int32(v int32) KeyValue {
80 return KeyValue{
81 Key: k,
82 Value: Int32Value(v),
83 }
84}
85
86// Uint32 creates a KeyValue instance with a UINT32 Value.
87//
88// If creating both key and a uint32 value at the same time, then
89// instead of calling Key(name).Uint32(value) consider using a
90// convenience function provided by the api/key package -
91// key.Uint32(name, value).
92func (k Key) Uint32(v uint32) KeyValue {
93 return KeyValue{
94 Key: k,
95 Value: Uint32Value(v),
96 }
97}
98
99// Float32 creates a KeyValue instance with a FLOAT32 Value.
100//
101// If creating both key and a float32 value at the same time, then
102// instead of calling Key(name).Float32(value) consider using a
103// convenience function provided by the api/key package -
104// key.Float32(name, value).
105func (k Key) Float32(v float32) KeyValue {
106 return KeyValue{
107 Key: k,
108 Value: Float32Value(v),
109 }
110}
111
112// String creates a KeyValue instance with a STRING Value.
113//
114// If creating both key and a string value at the same time, then
115// instead of calling Key(name).String(value) consider using a
116// convenience function provided by the api/key package -
117// key.String(name, value).
118func (k Key) String(v string) KeyValue {
119 return KeyValue{
120 Key: k,
121 Value: StringValue(v),
122 }
123}
124
125// Int creates a KeyValue instance with either an INT32 or an INT64
126// Value, depending on whether the int type is 32 or 64 bits wide.
127//
128// If creating both key and an int value at the same time, then
129// instead of calling Key(name).Int(value) consider using a
130// convenience function provided by the api/key package -
131// key.Int(name, value).
132func (k Key) Int(v int) KeyValue {
133 return KeyValue{
134 Key: k,
135 Value: IntValue(v),
136 }
137}
138
139// Uint creates a KeyValue instance with either a UINT32 or a UINT64
140// Value, depending on whether the uint type is 32 or 64 bits wide.
141//
142// If creating both key and a uint value at the same time, then
143// instead of calling Key(name).Uint(value) consider using a
144// convenience function provided by the api/key package -
145// key.Uint(name, value).
146func (k Key) Uint(v uint) KeyValue {
147 return KeyValue{
148 Key: k,
149 Value: UintValue(v),
150 }
151}
152
153// Defined returns true for non-empty keys.
154func (k Key) Defined() bool {
155 return len(k) != 0
156}
157
158// Array creates a KeyValue instance with a ARRAY Value.
159//
160// If creating both key and a array value at the same time, then
161// instead of calling Key(name).String(value) consider using a
162// convenience function provided by the api/key package -
163// key.Array(name, value).
164func (k Key) Array(v interface{}) KeyValue {
165 return KeyValue{
166 Key: k,
167 Value: ArrayValue(v),
168 }
169}