blob: dfead0829d6703235f6b50050f14092ca2e99aa3 [file] [log] [blame]
Don Newton7577f072020-01-06 12:41:11 -05001// 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 zapcore
22
23import "time"
24
25// MapObjectEncoder is an ObjectEncoder backed by a simple
26// map[string]interface{}. It's not fast enough for production use, but it's
27// helpful in tests.
28type MapObjectEncoder struct {
29 // Fields contains the entire encoded log context.
30 Fields map[string]interface{}
31 // cur is a pointer to the namespace we're currently writing to.
32 cur map[string]interface{}
33}
34
35// NewMapObjectEncoder creates a new map-backed ObjectEncoder.
36func NewMapObjectEncoder() *MapObjectEncoder {
37 m := make(map[string]interface{})
38 return &MapObjectEncoder{
39 Fields: m,
40 cur: m,
41 }
42}
43
44// AddArray implements ObjectEncoder.
45func (m *MapObjectEncoder) AddArray(key string, v ArrayMarshaler) error {
46 arr := &sliceArrayEncoder{elems: make([]interface{}, 0)}
47 err := v.MarshalLogArray(arr)
48 m.cur[key] = arr.elems
49 return err
50}
51
52// AddObject implements ObjectEncoder.
53func (m *MapObjectEncoder) AddObject(k string, v ObjectMarshaler) error {
54 newMap := NewMapObjectEncoder()
55 m.cur[k] = newMap.Fields
56 return v.MarshalLogObject(newMap)
57}
58
59// AddBinary implements ObjectEncoder.
60func (m *MapObjectEncoder) AddBinary(k string, v []byte) { m.cur[k] = v }
61
62// AddByteString implements ObjectEncoder.
63func (m *MapObjectEncoder) AddByteString(k string, v []byte) { m.cur[k] = string(v) }
64
65// AddBool implements ObjectEncoder.
66func (m *MapObjectEncoder) AddBool(k string, v bool) { m.cur[k] = v }
67
68// AddDuration implements ObjectEncoder.
69func (m MapObjectEncoder) AddDuration(k string, v time.Duration) { m.cur[k] = v }
70
71// AddComplex128 implements ObjectEncoder.
72func (m *MapObjectEncoder) AddComplex128(k string, v complex128) { m.cur[k] = v }
73
74// AddComplex64 implements ObjectEncoder.
75func (m *MapObjectEncoder) AddComplex64(k string, v complex64) { m.cur[k] = v }
76
77// AddFloat64 implements ObjectEncoder.
78func (m *MapObjectEncoder) AddFloat64(k string, v float64) { m.cur[k] = v }
79
80// AddFloat32 implements ObjectEncoder.
81func (m *MapObjectEncoder) AddFloat32(k string, v float32) { m.cur[k] = v }
82
83// AddInt implements ObjectEncoder.
84func (m *MapObjectEncoder) AddInt(k string, v int) { m.cur[k] = v }
85
86// AddInt64 implements ObjectEncoder.
87func (m *MapObjectEncoder) AddInt64(k string, v int64) { m.cur[k] = v }
88
89// AddInt32 implements ObjectEncoder.
90func (m *MapObjectEncoder) AddInt32(k string, v int32) { m.cur[k] = v }
91
92// AddInt16 implements ObjectEncoder.
93func (m *MapObjectEncoder) AddInt16(k string, v int16) { m.cur[k] = v }
94
95// AddInt8 implements ObjectEncoder.
96func (m *MapObjectEncoder) AddInt8(k string, v int8) { m.cur[k] = v }
97
98// AddString implements ObjectEncoder.
99func (m *MapObjectEncoder) AddString(k string, v string) { m.cur[k] = v }
100
101// AddTime implements ObjectEncoder.
102func (m MapObjectEncoder) AddTime(k string, v time.Time) { m.cur[k] = v }
103
104// AddUint implements ObjectEncoder.
105func (m *MapObjectEncoder) AddUint(k string, v uint) { m.cur[k] = v }
106
107// AddUint64 implements ObjectEncoder.
108func (m *MapObjectEncoder) AddUint64(k string, v uint64) { m.cur[k] = v }
109
110// AddUint32 implements ObjectEncoder.
111func (m *MapObjectEncoder) AddUint32(k string, v uint32) { m.cur[k] = v }
112
113// AddUint16 implements ObjectEncoder.
114func (m *MapObjectEncoder) AddUint16(k string, v uint16) { m.cur[k] = v }
115
116// AddUint8 implements ObjectEncoder.
117func (m *MapObjectEncoder) AddUint8(k string, v uint8) { m.cur[k] = v }
118
119// AddUintptr implements ObjectEncoder.
120func (m *MapObjectEncoder) AddUintptr(k string, v uintptr) { m.cur[k] = v }
121
122// AddReflected implements ObjectEncoder.
123func (m *MapObjectEncoder) AddReflected(k string, v interface{}) error {
124 m.cur[k] = v
125 return nil
126}
127
128// OpenNamespace implements ObjectEncoder.
129func (m *MapObjectEncoder) OpenNamespace(k string) {
130 ns := make(map[string]interface{})
131 m.cur[k] = ns
132 m.cur = ns
133}
134
135// sliceArrayEncoder is an ArrayEncoder backed by a simple []interface{}. Like
136// the MapObjectEncoder, it's not designed for production use.
137type sliceArrayEncoder struct {
138 elems []interface{}
139}
140
141func (s *sliceArrayEncoder) AppendArray(v ArrayMarshaler) error {
142 enc := &sliceArrayEncoder{}
143 err := v.MarshalLogArray(enc)
144 s.elems = append(s.elems, enc.elems)
145 return err
146}
147
148func (s *sliceArrayEncoder) AppendObject(v ObjectMarshaler) error {
149 m := NewMapObjectEncoder()
150 err := v.MarshalLogObject(m)
151 s.elems = append(s.elems, m.Fields)
152 return err
153}
154
155func (s *sliceArrayEncoder) AppendReflected(v interface{}) error {
156 s.elems = append(s.elems, v)
157 return nil
158}
159
160func (s *sliceArrayEncoder) AppendBool(v bool) { s.elems = append(s.elems, v) }
161func (s *sliceArrayEncoder) AppendByteString(v []byte) { s.elems = append(s.elems, string(v)) }
162func (s *sliceArrayEncoder) AppendComplex128(v complex128) { s.elems = append(s.elems, v) }
163func (s *sliceArrayEncoder) AppendComplex64(v complex64) { s.elems = append(s.elems, v) }
164func (s *sliceArrayEncoder) AppendDuration(v time.Duration) { s.elems = append(s.elems, v) }
165func (s *sliceArrayEncoder) AppendFloat64(v float64) { s.elems = append(s.elems, v) }
166func (s *sliceArrayEncoder) AppendFloat32(v float32) { s.elems = append(s.elems, v) }
167func (s *sliceArrayEncoder) AppendInt(v int) { s.elems = append(s.elems, v) }
168func (s *sliceArrayEncoder) AppendInt64(v int64) { s.elems = append(s.elems, v) }
169func (s *sliceArrayEncoder) AppendInt32(v int32) { s.elems = append(s.elems, v) }
170func (s *sliceArrayEncoder) AppendInt16(v int16) { s.elems = append(s.elems, v) }
171func (s *sliceArrayEncoder) AppendInt8(v int8) { s.elems = append(s.elems, v) }
172func (s *sliceArrayEncoder) AppendString(v string) { s.elems = append(s.elems, v) }
173func (s *sliceArrayEncoder) AppendTime(v time.Time) { s.elems = append(s.elems, v) }
174func (s *sliceArrayEncoder) AppendUint(v uint) { s.elems = append(s.elems, v) }
175func (s *sliceArrayEncoder) AppendUint64(v uint64) { s.elems = append(s.elems, v) }
176func (s *sliceArrayEncoder) AppendUint32(v uint32) { s.elems = append(s.elems, v) }
177func (s *sliceArrayEncoder) AppendUint16(v uint16) { s.elems = append(s.elems, v) }
178func (s *sliceArrayEncoder) AppendUint8(v uint8) { s.elems = append(s.elems, v) }
179func (s *sliceArrayEncoder) AppendUintptr(v uintptr) { s.elems = append(s.elems, v) }