func (m *Log) Size() (n int) {
	var l int
	_ = l
	if m.Time != nil {
		n += 1 + sovLog(uint64(*m.Time))
	}
	if len(m.Contents) > 0 {
		for _, e := range m.Contents {
			l = e.Size()
			n += 1 + l + sovLog(uint64(l))
		}
	}
	if m.XXXUnrecognized != nil {
		n += len(m.XXXUnrecognized)
	}
	return n
}
Size return the log's size
package alils
import (
	"fmt"
	"io"
	"math"
	"github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
)
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var (
	ErrInvalidLengthLog = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLog = fmt.Errorf("proto: integer overflow")
)
type Log struct {
	Time            *uint32       `protobuf:"varint,1,req,name=Time" json:"Time,omitempty"`
	Contents        []*LogContent `protobuf:"bytes,2,rep,name=Contents" json:"Contents,omitempty"`
	XXXUnrecognized []byte        `json:"-"`
}
func (m *Log) Reset() { *m = Log{} }
func (m *Log) String() string { return proto.CompactTextString(m) }
func (*Log) ProtoMessage() {}
func (m *Log) GetTime() uint32 {
	if m != nil && m.Time != nil {
		return *m.Time
	}
	return 0
}
func (m *Log) GetContents() []*LogContent {
	if m != nil {
		return m.Contents
	}
	return nil
}
type LogContent struct {
	Key             *string `protobuf:"bytes,1,req,name=Key" json:"Key,omitempty"`
	Value           *string `protobuf:"bytes,2,req,name=Value" json:"Value,omitempty"`
	XXXUnrecognized []byte  `json:"-"`
}
func (m *LogContent) Reset() { *m = LogContent{} }
func (m *LogContent) String() string { return proto.CompactTextString(m) }
func (*LogContent) ProtoMessage() {}
func (m *LogContent) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}
func (m *LogContent) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}
type LogGroup struct {
	Logs            []*Log  `protobuf:"bytes,1,rep,name=Logs" json:"Logs,omitempty"`
	Reserved        *string `protobuf:"bytes,2,opt,name=Reserved" json:"Reserved,omitempty"`
	Topic           *string `protobuf:"bytes,3,opt,name=Topic" json:"Topic,omitempty"`
	Source          *string `protobuf:"bytes,4,opt,name=Source" json:"Source,omitempty"`
	XXXUnrecognized []byte  `json:"-"`
}
func (m *LogGroup) Reset() { *m = LogGroup{} }
func (m *LogGroup) String() string { return proto.CompactTextString(m) }
func (*LogGroup) ProtoMessage() {}
func (m *LogGroup) GetLogs() []*Log {
	if m != nil {
		return m.Logs
	}
	return nil
}
func (m *LogGroup) GetReserved() string {
	if m != nil && m.Reserved != nil {
		return *m.Reserved
	}
	return ""
}
func (m *LogGroup) GetTopic() string {
	if m != nil && m.Topic != nil {
		return *m.Topic
	}
	return ""
}
func (m *LogGroup) GetSource() string {
	if m != nil && m.Source != nil {
		return *m.Source
	}
	return ""
}
type LogGroupList struct {
	LogGroups       []*LogGroup `protobuf:"bytes,1,rep,name=logGroups" json:"logGroups,omitempty"`
	XXXUnrecognized []byte      `json:"-"`
}
func (m *LogGroupList) Reset() { *m = LogGroupList{} }
func (m *LogGroupList) String() string { return proto.CompactTextString(m) }
func (*LogGroupList) ProtoMessage() {}
func (m *LogGroupList) GetLogGroups() []*LogGroup {
	if m != nil {
		return m.LogGroups
	}
	return nil
}
func (m *Log) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}
func (m *Log) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Time == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Time")
	}
	data[i] = 0x8
	i++
	i = encodeVarintLog(data, i, uint64(*m.Time))
	if len(m.Contents) > 0 {
		for _, msg := range m.Contents {
			data[i] = 0x12
			i++
			i = encodeVarintLog(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXXUnrecognized != nil {
		i += copy(data[i:], m.XXXUnrecognized)
	}
	return i, nil
}
func (m *LogContent) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}
func (m *LogContent) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Key == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Key")
	}
	data[i] = 0xa
	i++
	i = encodeVarintLog(data, i, uint64(len(*m.Key)))
	i += copy(data[i:], *m.Key)
	if m.Value == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("Value")
	}
	data[i] = 0x12
	i++
	i = encodeVarintLog(data, i, uint64(len(*m.Value)))
	i += copy(data[i:], *m.Value)
	if m.XXXUnrecognized != nil {
		i += copy(data[i:], m.XXXUnrecognized)
	}
	return i, nil
}
func (m *LogGroup) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}
func (m *LogGroup) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Logs) > 0 {
		for _, msg := range m.Logs {
			data[i] = 0xa
			i++
			i = encodeVarintLog(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Reserved != nil {
		data[i] = 0x12
		i++
		i = encodeVarintLog(data, i, uint64(len(*m.Reserved)))
		i += copy(data[i:], *m.Reserved)
	}
	if m.Topic != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintLog(data, i, uint64(len(*m.Topic)))
		i += copy(data[i:], *m.Topic)
	}
	if m.Source != nil {
		data[i] = 0x22
		i++
		i = encodeVarintLog(data, i, uint64(len(*m.Source)))
		i += copy(data[i:], *m.Source)
	}
	if m.XXXUnrecognized != nil {
		i += copy(data[i:], m.XXXUnrecognized)
	}
	return i, nil
}
func (m *LogGroupList) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}
func (m *LogGroupList) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.LogGroups) > 0 {
		for _, msg := range m.LogGroups {
			data[i] = 0xa
			i++
			i = encodeVarintLog(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXXUnrecognized != nil {
		i += copy(data[i:], m.XXXUnrecognized)
	}
	return i, nil
}
func encodeFixed64Log(data []byte, offset int, v uint64) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	data[offset+4] = uint8(v >> 32)
	data[offset+5] = uint8(v >> 40)
	data[offset+6] = uint8(v >> 48)
	data[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Log(data []byte, offset int, v uint32) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintLog(data []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		data[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	data[offset] = uint8(v)
	return offset + 1
}