Rework logging

wrappers/blockcipher.go

 	"crypto/cipher"
 	"net"
 
+	"go.uber.org/zap"
+
 	"github.com/9seconds/mtg/utils"
 	"github.com/juju/errors"
 )
 type BlockCipher struct {
 	buf *bytes.Buffer
 
+	logger    *zap.SugaredLogger
 	conn      StreamReadWriteCloser
 	encryptor cipher.BlockMode
 	decryptor cipher.BlockMode
 	return b.conn.Write(encrypted)
 }
 
-func (b *BlockCipher) LogDebug(msg string, data ...interface{}) {
-	b.conn.LogDebug(msg, data...)
-}
-
-func (b *BlockCipher) LogInfo(msg string, data ...interface{}) {
-	b.conn.LogInfo(msg, data...)
-}
-
-func (b *BlockCipher) LogWarn(msg string, data ...interface{}) {
-	b.conn.LogWarn(msg, data...)
-}
-
-func (b *BlockCipher) LogError(msg string, data ...interface{}) {
-	b.conn.LogError(msg, data...)
+func (b *BlockCipher) Logger() *zap.SugaredLogger {
+	return b.logger
 }
 
 func (b *BlockCipher) LocalAddr() *net.TCPAddr {
 	return &BlockCipher{
 		buf:       &bytes.Buffer{},
 		conn:      conn,
+		logger:    conn.Logger().Named("block-cipher"),
 		encryptor: encryptor,
 		decryptor: decryptor,
 	}

wrappers/conn.go

 }
 
 func (c *Conn) Close() error {
-	defer c.LogDebug("Closed connection")
+	defer c.logger.Debugw("Closed connection")
 	return c.conn.Close()
 }
 
 	return c.conn.RemoteAddr().(*net.TCPAddr)
 }
 
-func (c *Conn) LogDebug(msg string, data ...interface{}) {
-	c.logger.Debugw(msg, data...)
-}
-
-func (c *Conn) LogInfo(msg string, data ...interface{}) {
-	c.logger.Infow(msg, data...)
-}
-
-func (c *Conn) LogWarn(msg string, data ...interface{}) {
-	c.logger.Warnw(msg, data...)
-}
-
-func (c *Conn) LogError(msg string, data ...interface{}) {
-	c.logger.Errorw(msg, data...)
+func (c *Conn) Logger() *zap.SugaredLogger {
+	return c.logger
 }
 
 func NewConn(conn net.Conn, connID string, purpose ConnPurpose, publicIPv4, publicIPv6 net.IP) StreamReadWriteCloser {
 		"local_address", conn.LocalAddr(),
 		"remote_address", conn.RemoteAddr(),
 		"purpose", purpose,
-	)
+	).Named("conn")
 
 	wrapper := Conn{
 		logger:     logger,

wrappers/mtproto_abridged.go

 	"net"
 
 	"github.com/juju/errors"
+	"go.uber.org/zap"
 
 	"github.com/9seconds/mtg/mtproto"
 	"github.com/9seconds/mtg/utils"
 )
 
 type MTProtoAbridged struct {
-	conn StreamReadWriteCloser
-	opts *mtproto.ConnectionOpts
+	conn   StreamReadWriteCloser
+	opts   *mtproto.ConnectionOpts
+	logger *zap.SugaredLogger
 
 	readCounter  uint32
 	writeCounter uint32
 }
 
 func (m *MTProtoAbridged) Read() ([]byte, error) {
-	m.LogDebug("Read packet",
+	m.logger.Debugw("Read packet",
 		"simple_ack", m.opts.ReadHacks.SimpleAck,
 		"quick_ack", m.opts.ReadHacks.QuickAck,
 		"counter", m.readCounter,
 	msgLength := uint8(buf.Bytes()[0])
 	buf.Reset()
 
-	m.LogDebug("Packet first byte",
+	m.logger.Debugw("Packet first byte",
 		"byte", msgLength,
 		"counter", m.readCounter,
 		"simple_ack", m.opts.ReadHacks.SimpleAck,
 	}
 	msgLength32 *= 4
 
-	m.LogDebug("Packet length",
+	m.logger.Debugw("Packet length",
 		"length", msgLength32,
 		"simple_ack", m.opts.ReadHacks.SimpleAck,
 		"quick_ack", m.opts.ReadHacks.QuickAck,
 }
 
 func (m *MTProtoAbridged) Write(p []byte) (int, error) {
-	m.LogDebug("Write packet",
+	m.logger.Debugw("Write packet",
 		"length", len(p),
 		"simple_ack", m.opts.WriteHacks.SimpleAck,
 		"quick_ack", m.opts.WriteHacks.QuickAck,
 	return 0, errors.Errorf("Packet is too big %d", len(p))
 }
 
-func (m *MTProtoAbridged) LogDebug(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "abridged"}...)
-	m.conn.LogDebug(msg, data...)
-}
-
-func (m *MTProtoAbridged) LogInfo(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "abridged"}...)
-	m.conn.LogInfo(msg, data...)
-}
-
-func (m *MTProtoAbridged) LogWarn(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "abridged"}...)
-	m.conn.LogWarn(msg, data...)
-}
-
-func (m *MTProtoAbridged) LogError(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "abridged"}...)
-	m.conn.LogError(msg, data...)
+func (m *MTProtoAbridged) Logger() *zap.SugaredLogger {
+	return m.logger
 }
 
 func (m *MTProtoAbridged) LocalAddr() *net.TCPAddr {
 
 func NewMTProtoAbridged(conn StreamReadWriteCloser, opts *mtproto.ConnectionOpts) PacketReadWriteCloser {
 	return &MTProtoAbridged{
-		conn: conn,
-		opts: opts,
+		conn:   conn,
+		opts:   opts,
+		logger: conn.Logger().Named("mtproto-abridged"),
 	}
 }

wrappers/mtproto_frame.go

 	"net"
 
 	"github.com/juju/errors"
+	"go.uber.org/zap"
 )
 
 const (
 var mtprotoFramePadding = []byte{0x04, 0x00, 0x00, 0x00}
 
 type MTProtoFrame struct {
-	conn       StreamReadWriteCloser
+	conn   StreamReadWriteCloser
+	logger *zap.SugaredLogger
+
 	readSeqNo  int32
 	writeSeqNo int32
 }
 	}
 
 	messageLength := binary.LittleEndian.Uint32(buf.Bytes())
-	m.LogDebug("Read MTProto frame",
+	m.logger.Debugw("Read MTProto frame",
 		"messageLength", messageLength,
 		"sequence_number", m.readSeqNo,
 	)
 		return nil, errors.Errorf("CRC32 checksum mismatch. Wait for %d, got %d", sum.Sum32(), checksum)
 	}
 
-	m.LogDebug("Read MTProto frame",
+	m.logger.Debugw("Read MTProto frame",
 		"messageLength", messageLength,
 		"sequence_number", m.readSeqNo,
 		"dataLength", len(data),
 	binary.Write(buf, binary.LittleEndian, checksum)
 	buf.Write(bytes.Repeat(mtprotoFramePadding, paddingLength/4))
 
-	m.LogDebug("Write MTProto frame",
+	m.logger.Debugw("Write MTProto frame",
 		"length", len(p),
 		"sequence_number", m.writeSeqNo,
 		"crc32", checksum,
 	return len(p), err
 }
 
-func (m *MTProtoFrame) LogDebug(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "frame"}...)
-	m.conn.LogDebug(msg, data...)
-}
-
-func (m *MTProtoFrame) LogInfo(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "frame"}...)
-	m.conn.LogInfo(msg, data...)
-}
-
-func (m *MTProtoFrame) LogWarn(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "frame"}...)
-	m.conn.LogWarn(msg, data...)
-}
-
-func (m *MTProtoFrame) LogError(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "frame"}...)
-	m.conn.LogError(msg, data...)
+func (m *MTProtoFrame) Logger() *zap.SugaredLogger {
+	return m.logger
 }
 
 func (m *MTProtoFrame) LocalAddr() *net.TCPAddr {
 func NewMTProtoFrame(conn StreamReadWriteCloser, seqNo int32) PacketReadWriteCloser {
 	return &MTProtoFrame{
 		conn:       conn,
+		logger:     conn.Logger().Named("mtproto-frame"),
 		readSeqNo:  seqNo,
 		writeSeqNo: seqNo,
 	}

wrappers/mtproto_intermediate.go

 	"io"
 	"net"
 
-	"github.com/9seconds/mtg/mtproto"
 	"github.com/juju/errors"
+	"go.uber.org/zap"
+
+	"github.com/9seconds/mtg/mtproto"
 )
 
 const mtprotoIntermediateQuickAckLength = 0x80000000
 
 type MTProtoIntermediate struct {
-	conn StreamReadWriteCloser
-	opts *mtproto.ConnectionOpts
+	conn   StreamReadWriteCloser
+	opts   *mtproto.ConnectionOpts
+	logger *zap.SugaredLogger
 
 	readCounter  uint32
 	writeCounter uint32
 }
 
 func (m *MTProtoIntermediate) Read() ([]byte, error) {
-	m.LogDebug("Read packet",
+	m.logger.Debugw("Read packet",
 		"simple_ack", m.opts.ReadHacks.SimpleAck,
 		"quick_ack", m.opts.ReadHacks.QuickAck,
 		"counter", m.readCounter,
 	}
 	length := binary.LittleEndian.Uint32(buf.Bytes())
 
-	m.LogDebug("Packet message length",
+	m.logger.Debugw("Packet message length",
 		"simple_ack", m.opts.ReadHacks.SimpleAck,
 		"quick_ack", m.opts.ReadHacks.QuickAck,
 		"counter", m.readCounter,
 }
 
 func (m *MTProtoIntermediate) Write(p []byte) (int, error) {
-	m.LogDebug("Write packet",
+	m.logger.Debugw("Write packet",
 		"simple_ack", m.opts.WriteHacks.SimpleAck,
 		"quick_ack", m.opts.WriteHacks.QuickAck,
 		"counter", m.writeCounter,
 	return m.conn.Write(append(length[:], p...))
 }
 
-func (m *MTProtoIntermediate) LogDebug(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "intermediate"}...)
-	m.conn.LogDebug(msg, data...)
-}
-
-func (m *MTProtoIntermediate) LogInfo(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "intermediate"}...)
-	m.conn.LogInfo(msg, data...)
-}
-
-func (m *MTProtoIntermediate) LogWarn(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "intermediate"}...)
-	m.conn.LogWarn(msg, data...)
-}
-
-func (m *MTProtoIntermediate) LogError(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "intermediate"}...)
-	m.conn.LogError(msg, data...)
+func (m *MTProtoIntermediate) Logger() *zap.SugaredLogger {
+	return m.logger
 }
 
 func (m *MTProtoIntermediate) LocalAddr() *net.TCPAddr {
 
 func NewMTProtoIntermediate(conn StreamReadWriteCloser, opts *mtproto.ConnectionOpts) PacketReadWriteCloser {
 	return &MTProtoIntermediate{
-		conn: conn,
-		opts: opts,
+		conn:   conn,
+		logger: conn.Logger().Named("mtproto-intermediate"),
+		opts:   opts,
 	}
 }

wrappers/mtproto_proxy.go

 	"net"
 
 	"github.com/juju/errors"
+	"go.uber.org/zap"
 
 	"github.com/9seconds/mtg/mtproto"
 	"github.com/9seconds/mtg/mtproto/rpc"
 )
 
 type MTProtoProxy struct {
-	conn PacketReadWriteCloser
-	req  *rpc.ProxyRequest
+	conn   PacketReadWriteCloser
+	req    *rpc.ProxyRequest
+	logger *zap.SugaredLogger
 
 	readCounter  uint32
 	writeCounter uint32
 }
 
 func (m *MTProtoProxy) Read() ([]byte, error) {
-	m.LogDebug("Read packet",
+	m.logger.Debugw("Read packet",
 		"counter", m.readCounter,
 		"simple_ack", m.req.Options.WriteHacks.SimpleAck,
 		"quick_ack", m.req.Options.WriteHacks.QuickAck,
 	if err != nil {
 		return nil, errors.Annotate(err, "Cannot read packet")
 	}
-	m.LogDebug("Read packet length",
+	m.logger.Debugw("Read packet length",
 		"counter", m.readCounter,
 		"simple_ack", m.req.Options.WriteHacks.SimpleAck,
 		"quick_ack", m.req.Options.WriteHacks.QuickAck,
 	}
 
 	tag, packet := packet[:4], packet[4:]
-	m.LogDebug("Read RPC tag",
+	m.logger.Debugw("Read RPC tag",
 		"counter", m.readCounter,
 		"simple_ack", m.req.Options.WriteHacks.SimpleAck,
 		"quick_ack", m.req.Options.WriteHacks.QuickAck,
 }
 
 func (m *MTProtoProxy) Write(p []byte) (int, error) {
-	m.LogDebug("Write packet",
+	m.logger.Debugw("Write packet",
 		"length", len(p),
 		"counter", m.writeCounter,
 		"simple_ack", m.req.Options.ReadHacks.SimpleAck,
 	return len(p), nil
 }
 
-func (m *MTProtoProxy) LogDebug(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "proxy"}...)
-	m.conn.LogDebug(msg, data...)
-}
-
-func (m *MTProtoProxy) LogInfo(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "proxy"}...)
-	m.conn.LogInfo(msg, data...)
-}
-
-func (m *MTProtoProxy) LogWarn(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "proxy"}...)
-	m.conn.LogWarn(msg, data...)
-}
-
-func (m *MTProtoProxy) LogError(msg string, data ...interface{}) {
-	data = append(data, []interface{}{"type", "proxy"}...)
-	m.conn.LogError(msg, data...)
+func (m *MTProtoProxy) Logger() *zap.SugaredLogger {
+	return m.logger
 }
 
 func (m *MTProtoProxy) LocalAddr() *net.TCPAddr {
 	}
 
 	return &MTProtoProxy{
-		conn: conn,
-		req:  req,
+		conn:   conn,
+		logger: conn.Logger().Named("mtproto-proxy"),
+		req:    req,
 	}, nil
 }

wrappers/streamcipher.go

 	"net"
 
 	"github.com/juju/errors"
+	"go.uber.org/zap"
 )
 
 type StreamCipher struct {
 	encryptor cipher.Stream
 	decryptor cipher.Stream
 	conn      StreamReadWriteCloser
+	logger    *zap.SugaredLogger
 }
 
 func (s *StreamCipher) Read(p []byte) (int, error) {
 	return s.conn.Write(encrypted)
 }
 
-func (s *StreamCipher) LogDebug(msg string, data ...interface{}) {
-	s.conn.LogDebug(msg, data...)
-}
-
-func (s *StreamCipher) LogInfo(msg string, data ...interface{}) {
-	s.conn.LogInfo(msg, data...)
-}
-
-func (s *StreamCipher) LogWarn(msg string, data ...interface{}) {
-	s.conn.LogWarn(msg, data...)
-}
-
-func (s *StreamCipher) LogError(msg string, data ...interface{}) {
-	s.conn.LogError(msg, data...)
+func (s *StreamCipher) Logger() *zap.SugaredLogger {
+	return s.logger
 }
 
 func (s *StreamCipher) LocalAddr() *net.TCPAddr {
 func NewStreamCipher(conn StreamReadWriteCloser, encryptor, decryptor cipher.Stream) StreamReadWriteCloser {
 	return &StreamCipher{
 		conn:      conn,
+		logger:    conn.Logger().Named("stream-cipher"),
 		encryptor: encryptor,
 		decryptor: decryptor,
 	}

wrappers/wrap.go

 import (
 	"io"
 	"net"
+
+	"go.uber.org/zap"
 )
 
 type Wrap interface {
-	LogDebug(msg string, data ...interface{})
-	LogInfo(msg string, data ...interface{})
-	LogWarn(msg string, data ...interface{})
-	LogError(msg string, data ...interface{})
-
+	Logger() *zap.SugaredLogger
 	LocalAddr() *net.TCPAddr
 	RemoteAddr() *net.TCPAddr
 }