github.com/Laisky/zap@v1.27.0/zapcore/memory_encoder.go (about)

     1  // 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  
    21  package zapcore
    22  
    23  import "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.
    28  type 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.
    36  func NewMapObjectEncoder() *MapObjectEncoder {
    37  	m := make(map[string]interface{})
    38  	return &MapObjectEncoder{
    39  		Fields: m,
    40  		cur:    m,
    41  	}
    42  }
    43  
    44  // AddArray implements ObjectEncoder.
    45  func (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.
    53  func (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.
    60  func (m *MapObjectEncoder) AddBinary(k string, v []byte) { m.cur[k] = v }
    61  
    62  // AddByteString implements ObjectEncoder.
    63  func (m *MapObjectEncoder) AddByteString(k string, v []byte) { m.cur[k] = string(v) }
    64  
    65  // AddBool implements ObjectEncoder.
    66  func (m *MapObjectEncoder) AddBool(k string, v bool) { m.cur[k] = v }
    67  
    68  // AddDuration implements ObjectEncoder.
    69  func (m MapObjectEncoder) AddDuration(k string, v time.Duration) { m.cur[k] = v }
    70  
    71  // AddComplex128 implements ObjectEncoder.
    72  func (m *MapObjectEncoder) AddComplex128(k string, v complex128) { m.cur[k] = v }
    73  
    74  // AddComplex64 implements ObjectEncoder.
    75  func (m *MapObjectEncoder) AddComplex64(k string, v complex64) { m.cur[k] = v }
    76  
    77  // AddFloat64 implements ObjectEncoder.
    78  func (m *MapObjectEncoder) AddFloat64(k string, v float64) { m.cur[k] = v }
    79  
    80  // AddFloat32 implements ObjectEncoder.
    81  func (m *MapObjectEncoder) AddFloat32(k string, v float32) { m.cur[k] = v }
    82  
    83  // AddInt implements ObjectEncoder.
    84  func (m *MapObjectEncoder) AddInt(k string, v int) { m.cur[k] = v }
    85  
    86  // AddInt64 implements ObjectEncoder.
    87  func (m *MapObjectEncoder) AddInt64(k string, v int64) { m.cur[k] = v }
    88  
    89  // AddInt32 implements ObjectEncoder.
    90  func (m *MapObjectEncoder) AddInt32(k string, v int32) { m.cur[k] = v }
    91  
    92  // AddInt16 implements ObjectEncoder.
    93  func (m *MapObjectEncoder) AddInt16(k string, v int16) { m.cur[k] = v }
    94  
    95  // AddInt8 implements ObjectEncoder.
    96  func (m *MapObjectEncoder) AddInt8(k string, v int8) { m.cur[k] = v }
    97  
    98  // AddString implements ObjectEncoder.
    99  func (m *MapObjectEncoder) AddString(k string, v string) { m.cur[k] = v }
   100  
   101  // AddTime implements ObjectEncoder.
   102  func (m MapObjectEncoder) AddTime(k string, v time.Time) { m.cur[k] = v }
   103  
   104  // AddUint implements ObjectEncoder.
   105  func (m *MapObjectEncoder) AddUint(k string, v uint) { m.cur[k] = v }
   106  
   107  // AddUint64 implements ObjectEncoder.
   108  func (m *MapObjectEncoder) AddUint64(k string, v uint64) { m.cur[k] = v }
   109  
   110  // AddUint32 implements ObjectEncoder.
   111  func (m *MapObjectEncoder) AddUint32(k string, v uint32) { m.cur[k] = v }
   112  
   113  // AddUint16 implements ObjectEncoder.
   114  func (m *MapObjectEncoder) AddUint16(k string, v uint16) { m.cur[k] = v }
   115  
   116  // AddUint8 implements ObjectEncoder.
   117  func (m *MapObjectEncoder) AddUint8(k string, v uint8) { m.cur[k] = v }
   118  
   119  // AddUintptr implements ObjectEncoder.
   120  func (m *MapObjectEncoder) AddUintptr(k string, v uintptr) { m.cur[k] = v }
   121  
   122  // AddReflected implements ObjectEncoder.
   123  func (m *MapObjectEncoder) AddReflected(k string, v interface{}) error {
   124  	m.cur[k] = v
   125  	return nil
   126  }
   127  
   128  // OpenNamespace implements ObjectEncoder.
   129  func (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.
   137  type sliceArrayEncoder struct {
   138  	elems []interface{}
   139  }
   140  
   141  func (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  
   148  func (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  
   155  func (s *sliceArrayEncoder) AppendReflected(v interface{}) error {
   156  	s.elems = append(s.elems, v)
   157  	return nil
   158  }
   159  
   160  func (s *sliceArrayEncoder) AppendBool(v bool)              { s.elems = append(s.elems, v) }
   161  func (s *sliceArrayEncoder) AppendByteString(v []byte)      { s.elems = append(s.elems, string(v)) }
   162  func (s *sliceArrayEncoder) AppendComplex128(v complex128)  { s.elems = append(s.elems, v) }
   163  func (s *sliceArrayEncoder) AppendComplex64(v complex64)    { s.elems = append(s.elems, v) }
   164  func (s *sliceArrayEncoder) AppendDuration(v time.Duration) { s.elems = append(s.elems, v) }
   165  func (s *sliceArrayEncoder) AppendFloat64(v float64)        { s.elems = append(s.elems, v) }
   166  func (s *sliceArrayEncoder) AppendFloat32(v float32)        { s.elems = append(s.elems, v) }
   167  func (s *sliceArrayEncoder) AppendInt(v int)                { s.elems = append(s.elems, v) }
   168  func (s *sliceArrayEncoder) AppendInt64(v int64)            { s.elems = append(s.elems, v) }
   169  func (s *sliceArrayEncoder) AppendInt32(v int32)            { s.elems = append(s.elems, v) }
   170  func (s *sliceArrayEncoder) AppendInt16(v int16)            { s.elems = append(s.elems, v) }
   171  func (s *sliceArrayEncoder) AppendInt8(v int8)              { s.elems = append(s.elems, v) }
   172  func (s *sliceArrayEncoder) AppendString(v string)          { s.elems = append(s.elems, v) }
   173  func (s *sliceArrayEncoder) AppendTime(v time.Time)         { s.elems = append(s.elems, v) }
   174  func (s *sliceArrayEncoder) AppendUint(v uint)              { s.elems = append(s.elems, v) }
   175  func (s *sliceArrayEncoder) AppendUint64(v uint64)          { s.elems = append(s.elems, v) }
   176  func (s *sliceArrayEncoder) AppendUint32(v uint32)          { s.elems = append(s.elems, v) }
   177  func (s *sliceArrayEncoder) AppendUint16(v uint16)          { s.elems = append(s.elems, v) }
   178  func (s *sliceArrayEncoder) AppendUint8(v uint8)            { s.elems = append(s.elems, v) }
   179  func (s *sliceArrayEncoder) AppendUintptr(v uintptr)        { s.elems = append(s.elems, v) }