blob: 5be3704a3e11e09d228f80dfa9ba19da2402869c [file] [log] [blame]
Scott Baker2c1c4822019-10-16 11:02:41 -07001// Copyright (c) 2016 Uber Technologies, Inc.
2//
3// Permission is hereby granted, free of charge, to any person obtaining a copy
4// of this software and associated documentation files (the "Software"), to deal
5// in the Software without restriction, including without limitation the rights
6// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7// copies of the Software, and to permit persons to whom the Software is
8// furnished to do so, subject to the following conditions:
9//
10// The above copyright notice and this permission notice shall be included in
11// all copies or substantial portions of the Software.
12//
13// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19// THE SOFTWARE.
20
21package zap
22
23import (
24 "time"
25
26 "go.uber.org/zap/zapcore"
27)
28
29// Array constructs a field with the given key and ArrayMarshaler. It provides
30// a flexible, but still type-safe and efficient, way to add array-like types
31// to the logging context. The struct's MarshalLogArray method is called lazily.
32func Array(key string, val zapcore.ArrayMarshaler) Field {
33 return Field{Key: key, Type: zapcore.ArrayMarshalerType, Interface: val}
34}
35
36// Bools constructs a field that carries a slice of bools.
37func Bools(key string, bs []bool) Field {
38 return Array(key, bools(bs))
39}
40
41// ByteStrings constructs a field that carries a slice of []byte, each of which
42// must be UTF-8 encoded text.
43func ByteStrings(key string, bss [][]byte) Field {
44 return Array(key, byteStringsArray(bss))
45}
46
47// Complex128s constructs a field that carries a slice of complex numbers.
48func Complex128s(key string, nums []complex128) Field {
49 return Array(key, complex128s(nums))
50}
51
52// Complex64s constructs a field that carries a slice of complex numbers.
53func Complex64s(key string, nums []complex64) Field {
54 return Array(key, complex64s(nums))
55}
56
57// Durations constructs a field that carries a slice of time.Durations.
58func Durations(key string, ds []time.Duration) Field {
59 return Array(key, durations(ds))
60}
61
62// Float64s constructs a field that carries a slice of floats.
63func Float64s(key string, nums []float64) Field {
64 return Array(key, float64s(nums))
65}
66
67// Float32s constructs a field that carries a slice of floats.
68func Float32s(key string, nums []float32) Field {
69 return Array(key, float32s(nums))
70}
71
72// Ints constructs a field that carries a slice of integers.
73func Ints(key string, nums []int) Field {
74 return Array(key, ints(nums))
75}
76
77// Int64s constructs a field that carries a slice of integers.
78func Int64s(key string, nums []int64) Field {
79 return Array(key, int64s(nums))
80}
81
82// Int32s constructs a field that carries a slice of integers.
83func Int32s(key string, nums []int32) Field {
84 return Array(key, int32s(nums))
85}
86
87// Int16s constructs a field that carries a slice of integers.
88func Int16s(key string, nums []int16) Field {
89 return Array(key, int16s(nums))
90}
91
92// Int8s constructs a field that carries a slice of integers.
93func Int8s(key string, nums []int8) Field {
94 return Array(key, int8s(nums))
95}
96
97// Strings constructs a field that carries a slice of strings.
98func Strings(key string, ss []string) Field {
99 return Array(key, stringArray(ss))
100}
101
102// Times constructs a field that carries a slice of time.Times.
103func Times(key string, ts []time.Time) Field {
104 return Array(key, times(ts))
105}
106
107// Uints constructs a field that carries a slice of unsigned integers.
108func Uints(key string, nums []uint) Field {
109 return Array(key, uints(nums))
110}
111
112// Uint64s constructs a field that carries a slice of unsigned integers.
113func Uint64s(key string, nums []uint64) Field {
114 return Array(key, uint64s(nums))
115}
116
117// Uint32s constructs a field that carries a slice of unsigned integers.
118func Uint32s(key string, nums []uint32) Field {
119 return Array(key, uint32s(nums))
120}
121
122// Uint16s constructs a field that carries a slice of unsigned integers.
123func Uint16s(key string, nums []uint16) Field {
124 return Array(key, uint16s(nums))
125}
126
127// Uint8s constructs a field that carries a slice of unsigned integers.
128func Uint8s(key string, nums []uint8) Field {
129 return Array(key, uint8s(nums))
130}
131
132// Uintptrs constructs a field that carries a slice of pointer addresses.
133func Uintptrs(key string, us []uintptr) Field {
134 return Array(key, uintptrs(us))
135}
136
137// Errors constructs a field that carries a slice of errors.
138func Errors(key string, errs []error) Field {
139 return Array(key, errArray(errs))
140}
141
142type bools []bool
143
144func (bs bools) MarshalLogArray(arr zapcore.ArrayEncoder) error {
145 for i := range bs {
146 arr.AppendBool(bs[i])
147 }
148 return nil
149}
150
151type byteStringsArray [][]byte
152
153func (bss byteStringsArray) MarshalLogArray(arr zapcore.ArrayEncoder) error {
154 for i := range bss {
155 arr.AppendByteString(bss[i])
156 }
157 return nil
158}
159
160type complex128s []complex128
161
162func (nums complex128s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
163 for i := range nums {
164 arr.AppendComplex128(nums[i])
165 }
166 return nil
167}
168
169type complex64s []complex64
170
171func (nums complex64s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
172 for i := range nums {
173 arr.AppendComplex64(nums[i])
174 }
175 return nil
176}
177
178type durations []time.Duration
179
180func (ds durations) MarshalLogArray(arr zapcore.ArrayEncoder) error {
181 for i := range ds {
182 arr.AppendDuration(ds[i])
183 }
184 return nil
185}
186
187type float64s []float64
188
189func (nums float64s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
190 for i := range nums {
191 arr.AppendFloat64(nums[i])
192 }
193 return nil
194}
195
196type float32s []float32
197
198func (nums float32s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
199 for i := range nums {
200 arr.AppendFloat32(nums[i])
201 }
202 return nil
203}
204
205type ints []int
206
207func (nums ints) MarshalLogArray(arr zapcore.ArrayEncoder) error {
208 for i := range nums {
209 arr.AppendInt(nums[i])
210 }
211 return nil
212}
213
214type int64s []int64
215
216func (nums int64s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
217 for i := range nums {
218 arr.AppendInt64(nums[i])
219 }
220 return nil
221}
222
223type int32s []int32
224
225func (nums int32s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
226 for i := range nums {
227 arr.AppendInt32(nums[i])
228 }
229 return nil
230}
231
232type int16s []int16
233
234func (nums int16s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
235 for i := range nums {
236 arr.AppendInt16(nums[i])
237 }
238 return nil
239}
240
241type int8s []int8
242
243func (nums int8s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
244 for i := range nums {
245 arr.AppendInt8(nums[i])
246 }
247 return nil
248}
249
250type stringArray []string
251
252func (ss stringArray) MarshalLogArray(arr zapcore.ArrayEncoder) error {
253 for i := range ss {
254 arr.AppendString(ss[i])
255 }
256 return nil
257}
258
259type times []time.Time
260
261func (ts times) MarshalLogArray(arr zapcore.ArrayEncoder) error {
262 for i := range ts {
263 arr.AppendTime(ts[i])
264 }
265 return nil
266}
267
268type uints []uint
269
270func (nums uints) MarshalLogArray(arr zapcore.ArrayEncoder) error {
271 for i := range nums {
272 arr.AppendUint(nums[i])
273 }
274 return nil
275}
276
277type uint64s []uint64
278
279func (nums uint64s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
280 for i := range nums {
281 arr.AppendUint64(nums[i])
282 }
283 return nil
284}
285
286type uint32s []uint32
287
288func (nums uint32s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
289 for i := range nums {
290 arr.AppendUint32(nums[i])
291 }
292 return nil
293}
294
295type uint16s []uint16
296
297func (nums uint16s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
298 for i := range nums {
299 arr.AppendUint16(nums[i])
300 }
301 return nil
302}
303
304type uint8s []uint8
305
306func (nums uint8s) MarshalLogArray(arr zapcore.ArrayEncoder) error {
307 for i := range nums {
308 arr.AppendUint8(nums[i])
309 }
310 return nil
311}
312
313type uintptrs []uintptr
314
315func (nums uintptrs) MarshalLogArray(arr zapcore.ArrayEncoder) error {
316 for i := range nums {
317 arr.AppendUintptr(nums[i])
318 }
319 return nil
320}