Defer counters

wrappers/mtproto_abridged.go

 }
 
 func (m *MTProtoAbridged) Read() ([]byte, error) {
+	defer func() {
+		m.readCounter++
+	}()
+
 	m.logger.Debugw("Read packet",
 		"simple_ack", m.opts.ReadHacks.SimpleAck,
 		"quick_ack", m.opts.ReadHacks.QuickAck,
 
 	buf.Reset()
 	buf.Grow(int(msgLength32))
-
 	if _, err := io.CopyN(buf, m.conn, int64(msgLength32)); err != nil {
 		return nil, errors.Annotate(err, "Cannot read message")
 	}
-	m.readCounter++
 
 	return buf.Bytes(), nil
 }
 
 func (m *MTProtoAbridged) Write(p []byte) (int, error) {
+	defer func() {
+		m.writeCounter++
+	}()
+
 	m.logger.Debugw("Write packet",
 		"length", len(p),
 		"simple_ack", m.opts.WriteHacks.SimpleAck,
 	}
 
 	if m.opts.WriteHacks.SimpleAck {
-		m.writeCounter++
 		return m.conn.Write(utils.ReverseBytes(p))
 	}
 
 	switch {
 	case packetLength < mtprotoAbridgedSmallPacketLength:
 		newData := append([]byte{byte(packetLength)}, p...)
-
-		m.writeCounter++
 		return m.conn.Write(newData)
 
 	case packetLength < mtprotoAbridgedLargePacketLength:
 		buf.Write(length24[:])
 		buf.Write(p)
 
-		m.writeCounter++
 		return m.conn.Write(buf.Bytes())
 	}
 

wrappers/mtproto_intermediate.go

 }
 
 func (m *MTProtoIntermediate) Read() ([]byte, error) {
+	defer func() {
+		m.readCounter++
+	}()
+
 	m.logger.Debugw("Read packet",
 		"simple_ack", m.opts.ReadHacks.SimpleAck,
 		"quick_ack", m.opts.ReadHacks.QuickAck,
 	if length%4 != 0 {
 		length -= length % 4
 	}
-	m.readCounter++
 
 	return buf.Bytes()[:length], nil
 }
 
 func (m *MTProtoIntermediate) Write(p []byte) (int, error) {
+	defer func() {
+		m.writeCounter++
+	}()
+
 	m.logger.Debugw("Write packet",
 		"simple_ack", m.opts.WriteHacks.SimpleAck,
 		"quick_ack", m.opts.WriteHacks.QuickAck,
 		"counter", m.writeCounter,
 	)
-	m.writeCounter++
 
 	if m.opts.ReadHacks.SimpleAck {
 		return m.conn.Write(p)

wrappers/mtproto_proxy.go

 }
 
 func (m *MTProtoProxy) Read() ([]byte, error) {
+	defer func() {
+		m.readCounter++
+	}()
+
 	m.logger.Debugw("Read packet",
 		"counter", m.readCounter,
 		"simple_ack", m.req.Options.WriteHacks.SimpleAck,
 	if err != nil {
 		return nil, errors.Annotate(err, "Cannot read packet")
 	}
-	defer func() {
-		m.readCounter++
-	}()
 
 	m.logger.Debugw("Read packet length",
 		"counter", m.readCounter,
 }
 
 func (m *MTProtoProxy) Write(p []byte) (int, error) {
+	defer func() {
+		m.writeCounter++
+	}()
+
 	m.logger.Debugw("Write packet",
 		"length", len(p),
 		"counter", m.writeCounter,
 		"simple_ack", m.req.Options.ReadHacks.SimpleAck,
 		"quick_ack", m.req.Options.ReadHacks.QuickAck,
 	)
-	m.writeCounter++
 
 	header := m.req.MakeHeader(p)
 	if ce := m.logger.Desugar().Check(zap.DebugLevel, "RPC_PROXY_REQ header"); ce != nil {