move gocql: prefix to the legacy logger itself

Author: joao-r-reis

cluster.go

@@ -310,7 +310,7 @@ func (cfg *ClusterConfig) translateAddressPort(addr net.IP, port int, logger int
 		return addr, port
 	}
 	newAddr, newPort := cfg.AddressTranslator.Translate(addr, port)
-	logger.Debug("gocql: translating address '%v:%d' to '%v:%d'",
+	logger.Debug("translating address '%v:%d' to '%v:%d'",
 		NewLogField("old_addr", addr), NewLogField("old_port", port),
 		NewLogField("new_addr", newAddr), NewLogField("new_port", newPort))
 	return newAddr, newPort

conn.go

@@ -701,7 +701,7 @@ func (c *Conn) recv(ctx context.Context) error {
 	delete(c.calls, head.stream)
 	c.mu.Unlock()
 	if call == nil || !ok {
-		c.logger.Warning("gocql: received response for stream which has no handler: header=%v\n", NewLogField("header", head))
+		c.logger.Warning("received response for stream which has no handler: header=%v", NewLogField("header", head))
 		return c.discardFrame(head)
 	} else if head.stream != call.streamID {
 		panic(fmt.Sprintf("call has incorrect streamID: got %d expected %d", call.streamID, head.stream))
@@ -1445,7 +1445,7 @@ func (c *Conn) executeQuery(ctx context.Context, qry *Query) *Iter {
 		iter := &Iter{framer: framer}
 		if err := c.awaitSchemaAgreement(ctx); err != nil {
 			// TODO: should have this behind a flag
-			c.logger.Warning("gocql: error while awaiting for schema agreement after a schema change event: %v", NewLogField("err", err.Error()))
+			c.logger.Warning("error while awaiting for schema agreement after a schema change event: %v", NewLogField("err", err.Error()))
 		}
 		// dont return an error from this, might be a good idea to give a warning
 		// though. The impact of this returning an error would be that the cluster
@@ -1685,7 +1685,7 @@ func (c *Conn) awaitSchemaAgreement(ctx context.Context) (err error) {
 				goto cont
 			}
 			if !isValidPeer(host) || host.schemaVersion == "" {
-				c.logger.Warning("gocql: invalid peer or peer with empty schema_version: peer=%s", NewLogField("peer", host.ConnectAddress()))
+				c.logger.Warning("invalid peer or peer with empty schema_version: peer=%s", NewLogField("peer", host.ConnectAddress()))
 				continue
 			}
 

connectionpool.go

@@ -468,19 +468,19 @@ func (pool *hostConnPool) logConnectErr(err error) {
 	if opErr, ok := err.(*net.OpError); ok && (opErr.Op == "dial" || opErr.Op == "read") {
 		// connection refused
 		// these are typical during a node outage so avoid log spam.
-		pool.logger.Debug("gocql: unable to dial %s (%s): %v\n",
+		pool.logger.Debug("unable to dial %s (%s): %v",
 			NewLogField("host_addr", pool.host.ConnectAddress()), NewLogField("host_id", pool.host.HostID()), NewLogField("err", err.Error()))
 	} else if err != nil {
 		// unexpected error
-		pool.logger.Debug("gocql: failed to connect to %s (%s) due to error: %v",
+		pool.logger.Debug("failed to connect to %s (%s) due to error: %v",
 			NewLogField("host_addr", pool.host.ConnectAddress()), NewLogField("host_id", pool.host.HostID()), NewLogField("err", err.Error()))
 	}
 }
 
 // transition back to a not-filling state.
 func (pool *hostConnPool) fillingStopped(err error) {
 	if err != nil {
-		pool.logger.Warning("gocql: connection pool filling failed %s (%s): %v\n",
+		pool.logger.Warning("connection pool filling failed %s (%s): %v",
 			NewLogField("host_addr", pool.host.ConnectAddress()), NewLogField("host_id", pool.host.HostID()), NewLogField("err", err.Error()))
 		// wait for some time to avoid back-to-back filling
 		// this provides some time between failed attempts
@@ -497,7 +497,7 @@ func (pool *hostConnPool) fillingStopped(err error) {
 
 	// if we errored and the size is now zero, make sure the host is marked as down
 	// see https://github.com/gocql/gocql/issues/1614
-	pool.logger.Debug("gocql: conns of pool after stopped %s (%s): %v\n",
+	pool.logger.Debug("conns of pool after stopped %s (%s): %v",
 		NewLogField("host_addr", host.ConnectAddress()), NewLogField("host_id", host.HostID()), NewLogField("count", count))
 	if err != nil && count == 0 {
 		if pool.session.cfg.ConvictionPolicy.AddFailure(err, host) {
@@ -554,7 +554,7 @@ func (pool *hostConnPool) connect() (err error) {
 				break
 			}
 		}
-		pool.logger.Warning("gocql: connection failed %s (%s): %v, reconnecting with %v\n",
+		pool.logger.Warning("connection failed %s (%s): %v, reconnecting with %v",
 			NewLogField("host", pool.host.ConnectAddress()),
 			NewLogField("host_id", pool.host.HostID()),
 			NewLogField("err", err.Error()),
@@ -605,7 +605,7 @@ func (pool *hostConnPool) HandleError(conn *Conn, err error, closed bool) {
 		return
 	}
 
-	pool.logger.Info("gocql: pool connection error %v: %v\n",
+	pool.logger.Info("pool connection error %v: %v",
 		NewLogField("addr", conn.addr), NewLogField("err", err.Error()))
 
 	// find the connection index

control.go

@@ -81,7 +81,7 @@ func (c *controlConn) heartBeat() {
 
 		resp, err := c.writeFrame(&writeOptionsFrame{})
 		if err != nil {
-			c.session.logger.Debug("gocql: control connection heartbeat failed: %v.", NewLogField("err", err.Error()))
+			c.session.logger.Debug("control connection heartbeat failed: %v.", NewLogField("err", err.Error()))
 			goto reconn
 		}
 
@@ -91,10 +91,10 @@ func (c *controlConn) heartBeat() {
 			sleepTime = 5 * time.Second
 			continue
 		case error:
-			c.session.logger.Debug("gocql: control connection heartbeat failed: %v.", NewLogField("err", actualResp.Error()))
+			c.session.logger.Debug("control connection heartbeat failed: %v.", NewLogField("err", actualResp.Error()))
 			goto reconn
 		default:
-			c.session.logger.Error("gocql: unknown frame in response to options: %v", NewLogField("frame_type", fmt.Sprintf("%T", resp)))
+			c.session.logger.Error("unknown frame in response to options: %v", NewLogField("frame_type", fmt.Sprintf("%T", resp)))
 		}
 
 	reconn:
@@ -213,18 +213,18 @@ func (c *controlConn) discoverProtocol(hosts []*HostInfo) (int, error) {
 		}
 
 		if err == nil {
-			c.session.logger.Debug("gocql: discovered protocol version %v using host %v (%s).",
+			c.session.logger.Debug("discovered protocol version %v using host %v (%s).",
 				NewLogField("protocol_version", connCfg.ProtoVersion), NewLogField("host_addr", host.ConnectAddress()), NewLogField("host_id", host.HostID()))
 			return connCfg.ProtoVersion, nil
 		}
 
 		if proto := parseProtocolFromError(err); proto > 0 {
-			c.session.logger.Debug("gocql: discovered protocol version %v using host %v (%s).",
+			c.session.logger.Debug("discovered protocol version %v using host %v (%s).",
 				NewLogField("protocol_version", proto), NewLogField("host_addr", host.ConnectAddress()), NewLogField("host_id", host.HostID()))
 			return proto, nil
 		}
 
-		c.session.logger.Debug("gocql: failed to discover protocol version using host %v (%v): %v.",
+		c.session.logger.Debug("failed to discover protocol version using host %v (%v): %v.",
 			NewLogField("host_addr", host.ConnectAddress()), NewLogField("host_id", host.HostID()), NewLogField("err", err.Error()))
 	}
 
@@ -248,7 +248,7 @@ func (c *controlConn) connect(hosts []*HostInfo) error {
 	for _, host := range hosts {
 		conn, err = c.session.dial(c.session.ctx, host, &cfg, c)
 		if err != nil {
-			c.session.logger.Info("gocql: unable to dial control conn %s:%v (%s): %v\n",
+			c.session.logger.Info("unable to dial control conn %s:%v (%s): %v",
 				NewLogField("host_addr", host.ConnectAddress()),
 				NewLogField("port", host.Port()),
 				NewLogField("host_id", host.HostID()),
@@ -259,7 +259,7 @@ func (c *controlConn) connect(hosts []*HostInfo) error {
 		if err == nil {
 			break
 		}
-		c.session.logger.Info("gocql: unable setup control conn %v:%v (%s): %v\n",
+		c.session.logger.Info("unable setup control conn %v:%v (%s): %v",
 			NewLogField("host_addr", host.ConnectAddress()),
 			NewLogField("port", host.Port()),
 			NewLogField("host_id", host.HostID()),
@@ -300,7 +300,7 @@ func (c *controlConn) setupConn(conn *Conn) error {
 	}
 
 	if !exists {
-		c.session.logger.Info("gocql: adding host %v (%v).",
+		c.session.logger.Info("adding host %v (%v).",
 			NewLogField("host_addr", host.ConnectAddress().String()), NewLogField("host_id", host.HostID()))
 	}
 
@@ -315,7 +315,7 @@ func (c *controlConn) setupConn(conn *Conn) error {
 
 	c.conn.Store(ch)
 
-	c.session.logger.Info("gocql: control connection connected to %v (%s).",
+	c.session.logger.Info("control connection connected to %v (%s).",
 		NewLogField("host_addr", host.ConnectAddress().String()), NewLogField("host_id", host.HostID()))
 
 	if c.session.initialized() {
@@ -359,7 +359,7 @@ func (c *controlConn) registerEvents(conn *Conn) error {
 	if err != nil {
 		return err
 	} else if _, ok := frame.(*readyFrame); !ok {
-		return fmt.Errorf("unexpected frame in response to register: got %T: %v\n", frame, frame)
+		return fmt.Errorf("unexpected frame in response to register: got %T: %v", frame, frame)
 	}
 
 	return nil
@@ -377,21 +377,21 @@ func (c *controlConn) reconnect() {
 	_, err := c.attemptReconnect()
 
 	if err != nil {
-		c.session.logger.Error("gocql: unable to reconnect control connection: %v\n",
+		c.session.logger.Error("unable to reconnect control connection: %v",
 			NewLogField("err", err.Error()))
 		return
 	}
 
 	err = c.session.refreshRing()
 	if err != nil {
-		c.session.logger.Warning("gocql: unable to refresh ring: %v\n",
+		c.session.logger.Warning("unable to refresh ring: %v",
 			NewLogField("err", err.Error()))
 	}
 }
 
 func (c *controlConn) attemptReconnect() (*Conn, error) {
 
-	c.session.logger.Info("gocql: reconnecting the control connection.")
+	c.session.logger.Info("reconnecting the control connection.")
 
 	hosts := c.session.ring.allHosts()
 	hosts = shuffleHosts(hosts)
@@ -415,7 +415,7 @@ func (c *controlConn) attemptReconnect() (*Conn, error) {
 		return conn, err
 	}
 
-	c.session.logger.Error("gocql: unable to connect to any ring node, control connection falling back to initial contact points: %v", NewLogField("err", err.Error()))
+	c.session.logger.Error("unable to connect to any ring node, control connection falling back to initial contact points: %v", NewLogField("err", err.Error()))
 	// Fallback to initial contact points, as it may be the case that all known initialHosts
 	// changed their IPs while keeping the same hostname(s).
 	initialHosts, resolvErr := addrsToHosts(c.session.cfg.Hosts, c.session.cfg.Port, c.session.logger)
@@ -432,7 +432,7 @@ func (c *controlConn) attemptReconnectToAnyOfHosts(hosts []*HostInfo) (*Conn, er
 	for _, host := range hosts {
 		conn, err = c.session.connect(c.session.ctx, host, c)
 		if err != nil {
-			c.session.logger.Info("gocql: unable to dial control conn %s:%v (%s): %v\n",
+			c.session.logger.Info("unable to dial control conn %s:%v (%s): %v",
 				NewLogField("host_addr", host.ConnectAddress()),
 				NewLogField("port", host.Port()),
 				NewLogField("host_id", host.HostID()),
@@ -443,7 +443,7 @@ func (c *controlConn) attemptReconnectToAnyOfHosts(hosts []*HostInfo) (*Conn, er
 		if err == nil {
 			break
 		}
-		c.session.logger.Info("gocql: unable setup control conn %v:%v (%s): %v\n",
+		c.session.logger.Info("unable setup control conn %v:%v (%s): %v",
 			NewLogField("host_addr", host.ConnectAddress()),
 			NewLogField("port", host.Port()),
 			NewLogField("host_id", host.HostID()),
@@ -467,7 +467,7 @@ func (c *controlConn) HandleError(conn *Conn, err error, closed bool) {
 		return
 	}
 
-	c.session.logger.Info("gocql: control connection error %v (%s): %v\n",
+	c.session.logger.Info("control connection error %v (%s): %v",
 		NewLogField("host_addr", conn.host.ConnectAddress().String()),
 		NewLogField("host_id", conn.host.HostID()),
 		NewLogField("err", err.Error()))
@@ -534,7 +534,7 @@ func (c *controlConn) query(statement string, values ...interface{}) (iter *Iter
 		})
 
 		if iter.err != nil {
-			c.session.logger.Warning("control: error executing %v: %v\n",
+			c.session.logger.Warning("control: error executing %v: %v",
 				NewLogField("statement", statement), NewLogField("err", iter.err.Error()))
 		}
 

events.go

@@ -79,7 +79,7 @@ func (e *eventDebouncer) debounce(frame frame) {
 	if len(e.events) < eventBufferSize {
 		e.events = append(e.events, frame)
 	} else {
-		e.logger.Warning("gocql: %s: buffer full, dropping event frame: %s",
+		e.logger.Warning("%s: buffer full, dropping event frame: %s",
 			NewLogField("event_name", e.name), NewLogField("frame", frame))
 	}
 
@@ -89,11 +89,11 @@ func (e *eventDebouncer) debounce(frame frame) {
 func (s *Session) handleEvent(framer *framer) {
 	frame, err := framer.parseFrame()
 	if err != nil {
-		s.logger.Error("gocql: unable to parse event frame: %v\n", NewLogField("err", err.Error()))
+		s.logger.Error("unable to parse event frame: %v", NewLogField("err", err.Error()))
 		return
 	}
 
-	s.logger.Debug("gocql: handling event frame: %v\n", NewLogField("frame", frame.String()))
+	s.logger.Debug("handling event frame: %v", NewLogField("frame", frame.String()))
 
 	switch f := frame.(type) {
 	case *schemaChangeKeyspace, *schemaChangeFunction,
@@ -103,7 +103,7 @@ func (s *Session) handleEvent(framer *framer) {
 	case *topologyChangeEventFrame, *statusChangeEventFrame:
 		s.nodeEvents.debounce(frame)
 	default:
-		s.logger.Error("gocql: invalid event frame (%v): %v\n",
+		s.logger.Error("invalid event frame (%v): %v",
 			NewLogField("frame_type", fmt.Sprintf("%T", f)), NewLogField("frame", f.String()))
 	}
 }
@@ -156,7 +156,7 @@ func (s *Session) handleNodeEvent(frames []frame) {
 	for _, frame := range frames {
 		switch f := frame.(type) {
 		case *topologyChangeEventFrame:
-			s.logger.Warning("gocql: received topology change event: %v",
+			s.logger.Warning("received topology change event: %v",
 				NewLogField("frame", strings.Join([]string{f.change, "->", f.host.String(), ":", strconv.Itoa(f.port)}, "")))
 			topologyEventReceived = true
 		case *statusChangeEventFrame:
@@ -174,7 +174,7 @@ func (s *Session) handleNodeEvent(frames []frame) {
 	}
 
 	for _, f := range sEvents {
-		s.logger.Info("gocql: dispatching status change event: %v\n",
+		s.logger.Info("dispatching status change event: %v",
 			NewLogField("frame", strings.Join([]string{f.change, "->", f.host.String(), ":", strconv.Itoa(f.port)}, "")))
 
 		// ignore events we received if they were disabled
@@ -193,7 +193,7 @@ func (s *Session) handleNodeEvent(frames []frame) {
 }
 
 func (s *Session) handleNodeUp(eventIp net.IP, eventPort int) {
-	s.logger.Info("gocql: node is UP: %s:%d\n",
+	s.logger.Info("node is UP: %s:%d",
 		NewLogField("event_ip", eventIp.String()), NewLogField("event_port", eventPort))
 
 	host, ok := s.ring.getHostByIP(eventIp.String())
@@ -219,7 +219,7 @@ func (s *Session) startPoolFill(host *HostInfo) {
 }
 
 func (s *Session) handleNodeConnected(host *HostInfo) {
-	s.logger.Debug("gocql: connected to node: %s:%d (%s)\n",
+	s.logger.Debug("connected to node: %s:%d (%s)",
 		NewLogField("host_addr", host.ConnectAddress()), NewLogField("port", host.Port()), NewLogField("host_id", host.HostID()))
 
 	host.setState(NodeUp)
@@ -230,7 +230,7 @@ func (s *Session) handleNodeConnected(host *HostInfo) {
 }
 
 func (s *Session) handleNodeDown(ip net.IP, port int) {
-	s.logger.Warning("gocql: node is DOWN: %s:%d\n",
+	s.logger.Warning("node is DOWN: %s:%d",
 		NewLogField("host_addr", ip.String()), NewLogField("port", port))
 
 	host, ok := s.ring.getHostByIP(ip.String())

helpers.go

@@ -159,7 +159,7 @@ func getCassandraType(name string, logger internalLogger) TypeInfo {
 	} else if strings.HasPrefix(name, "map<") {
 		names := splitCompositeTypes(strings.TrimPrefix(name[:len(name)-1], "map<"))
 		if len(names) != 2 {
-			logger.Warning("gocql: error parsing map type, it has %d subelements, expecting 2\n",
+			logger.Warning("error parsing map type, it has %d subelements, expecting 2",
 				NewLogField("subelements_number", len(names)))
 			return NativeType{
 				typ: TypeCustom,

host_source.go

@@ -633,7 +633,7 @@ func (r *ringDescriber) getClusterPeerInfo(localHost *HostInfo) ([]*HostInfo, er
 			return nil, err
 		} else if !isValidPeer(host) {
 			// If it's not a valid peer
-			r.session.logger.Warning("gocql: found invalid peer '%s' "+
+			r.session.logger.Warning("found invalid peer '%s' "+
 				"Likely due to a gossip or snitch issue, this host will be ignored", NewLogField("host", host))
 			continue
 		}
@@ -706,7 +706,7 @@ func refreshRing(r *ringDescriber) error {
 		}
 
 		if host, ok := r.session.ring.addHostIfMissing(h); !ok {
-			r.session.logger.Info("gocql: adding host %v (%v).", NewLogField("host_addr", h.ConnectAddress().String()), NewLogField("host_id", h.HostID()))
+			r.session.logger.Info("adding host %v (%v).", NewLogField("host_addr", h.ConnectAddress().String()), NewLogField("host_id", h.HostID()))
 			r.session.startPoolFill(h)
 		} else {
 			// host (by hostID) already exists; determine if IP has changed
@@ -725,7 +725,7 @@ func refreshRing(r *ringDescriber) error {
 				if _, alreadyExists := r.session.ring.addHostIfMissing(h); alreadyExists {
 					return fmt.Errorf("add new host=%s after removal: %w", h, ErrHostAlreadyExists)
 				}
-				r.session.logger.Info("gocql: adding host %v (%v).", NewLogField("host_addr", h.ConnectAddress().String()), NewLogField("host_id", h.HostID()))
+				r.session.logger.Info("adding host %v (%v).", NewLogField("host_addr", h.ConnectAddress().String()), NewLogField("host_id", h.HostID()))
 				// add new HostInfo (same hostID, new IP)
 				r.session.startPoolFill(h)
 			}
@@ -739,7 +739,7 @@ func refreshRing(r *ringDescriber) error {
 
 	r.session.metadata.setPartitioner(partitioner)
 	r.session.policy.SetPartitioner(partitioner)
-	r.session.logger.Info("gocql: refreshed ring: %v.", NewLogField("ring", ringString(r.session.ring.allHosts())))
+	r.session.logger.Info("refreshed ring: %v.", NewLogField("ring", ringString(r.session.ring.allHosts())))
 	return nil
 }
 

logger.go

@@ -149,7 +149,7 @@ func (recv loggerAdapter) logLegacy(msg string, fields ...LogField) {
 		values[i] = v.Value
 		i++
 	}
-	recv.legacyLogger.Printf(msg, values...)
+	recv.legacyLogger.Printf(strings.Join([]string{"gocql: ", msg, "\n"}, ""), values...)
 }
 
 func (recv loggerAdapter) Error(msg string, fields ...LogField) {

metadata.go

@@ -1235,7 +1235,7 @@ func (t *typeParser) parse() typeParserResult {
 				decoded, err := hex.DecodeString(*param.name)
 				if err != nil {
 					t.logger.Warning(
-						"gocql: error parsing type '%s', contains collection name '%s' with an invalid format: %v",
+						"error parsing type '%s', contains collection name '%s' with an invalid format: %v",
 						NewLogField("type", t.input),
 						NewLogField("collection_name", *param.name),
 						NewLogField("err", err.Error()),

policies.go

@@ -550,7 +550,7 @@ func (m *clusterMeta) resetTokenRing(partitioner string, hosts []*HostInfo, logg
 	// create a new token ring
 	tokenRing, err := newTokenRing(partitioner, hosts)
 	if err != nil {
-		logger.Warning("gocql: unable to update the token ring due to error: %s", NewLogField("err", err.Error()))
+		logger.Warning("unable to update the token ring due to error: %s", NewLogField("err", err.Error()))
 		return
 	}