Add testcase && hook logger for server

server/hooks.go

@@ -0,0 +1,44 @@
+package server
+
+import (
+	"context"
+	"strings"
+
+	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/metadata"
+)
+
+func NewLoggerHookSubHandler(extractKeys ...string) HookSubHandler {
+	return func(next FuncSubHandler) FuncSubHandler {
+		return func(ctx context.Context, msg Message) (err error) {
+			log := logger.MustContext(ctx)
+			attrs := []interface{}{"endpoint", msg.Topic()}
+
+			if md, ok := metadata.FromIncomingContext(ctx); ok {
+				for idx := range extractKeys {
+					if val, ok := md.Get(extractKeys[idx]); ok {
+						attrs = append(attrs, strings.ToLower(extractKeys[idx]), val)
+					}
+				}
+			}
+
+			log = log.Fields(attrs...)
+			ctx = logger.NewContext(ctx, log)
+
+			if log.V(logger.DebugLevel) {
+				log.Fields(
+					//	"payload", MarshalJSON(msg.Body()),
+					"headers", msg.Header(),
+				).Debug(ctx, "subscriber called")
+			}
+
+			if err = next(ctx, msg); err != nil {
+				log.Error(ctx, "subscriber finished with error", err)
+			} else {
+				log.Debug(ctx, "subscriber finished")
+			}
+
+			return err
+		}
+	}
+}

server/noop_test.go

@@ -4,12 +4,20 @@ import (
 	"context"
 	"fmt"
 	"testing"
+	"time"
 
+	kgo "go.unistack.org/micro-broker-kgo/v3"
+	requestid "go.unistack.org/micro-wrapper-requestid/v3"
+	"go.unistack.org/micro/v3"
 	"go.unistack.org/micro/v3/broker"
 	"go.unistack.org/micro/v3/client"
 	"go.unistack.org/micro/v3/codec"
 	"go.unistack.org/micro/v3/logger"
+	"go.unistack.org/micro/v3/logger/slog"
+	"go.unistack.org/micro/v3/metadata"
 	"go.unistack.org/micro/v3/server"
+
+	"github.com/google/uuid"
 )
 
 type TestHandler struct {
@@ -21,7 +29,8 @@ type TestMessage struct {
 }
 
 func (h *TestHandler) SingleSubHandler(ctx context.Context, msg *codec.Frame) error {
-	// fmt.Printf("msg %s\n", msg.Data)
+	log := logger.MustContext(ctx)
+	log.Info(ctx, fmt.Sprintf("%s", msg.Data))
 	return nil
 }
 
@@ -82,3 +91,107 @@ func TestNoopSub(t *testing.T) {
 		}
 	}()
 }
+
+func TestConsumerAndServer(t *testing.T) {
+	const (
+		topicTarget  = "single_topic"
+		addressKafka = "localhost:9092"
+	)
+
+	ctx := context.Background()
+	logger.DefaultLogger = slog.NewLogger()
+	logger.DefaultLogger.Init(logger.WithLevel(logger.DebugLevel))
+	rh := requestid.NewHook()
+
+	b := kgo.NewBroker(
+		kgo.CommitInterval(1*time.Second),
+		broker.Addrs(addressKafka),
+		broker.Logger(logger.DefaultLogger.Clone(logger.WithLevel(logger.ParseLevel("error")))),
+		broker.ErrorHandler(func(event broker.Event) error {
+			msg := event.Message()
+			log := logger.DefaultLogger.
+				Fields("topic", event.Topic(),
+					"header", msg.Header,
+					"body", msg.Body)
+			err := event.Ack()
+
+			if err != nil {
+				log.Fields("ack_error", err).Error(context.Background(), fmt.Sprintf("brokerHandlerErr: Ack error | %v", event.Error()))
+				return err
+			}
+
+			log.Error(context.Background(), fmt.Sprintf("brokerHandlerErr: %v", event.Error()))
+
+			return nil
+		}),
+	)
+
+	if err := b.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := b.Connect(ctx); err != nil {
+		t.Fatal(err)
+	}
+
+	s := server.NewServer(
+		server.Broker(b),
+		server.Codec("application/octet-stream", codec.NewCodec()),
+		server.Hooks(
+			server.NewLoggerHookSubHandler(metadata.HeaderEndpoint),
+			server.HookSubHandler(rh.ServerSubscriber),
+		),
+	)
+	if err := s.Init(); err != nil {
+		t.Fatal(err)
+	}
+
+	c := client.NewClient(
+		client.Broker(b),
+		client.Codec("application/octet-stream", codec.NewCodec()),
+		client.ContentType("application/octet-stream"),
+	)
+	if err := c.Init(); err != nil {
+		t.Fatal(err)
+	}
+	h := &TestHandler{t: t}
+
+	if err := s.Subscribe(s.NewSubscriber(topicTarget, h.SingleSubHandler,
+		server.SubscriberQueue("queue"),
+	)); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := s.Start(); err != nil {
+		t.Fatal(err)
+	}
+
+	msgs := make([]client.Message, 0, 8)
+	for i := 0; i < 8; i++ {
+		req := &codec.Frame{Data: []byte(fmt.Sprintf(`{"name": "test_name %d"}`, i))}
+
+		opts := []client.MessageOption{
+			client.MessageMetadata(metadata.HeaderXRequestID, uuid.NewString()),
+			client.MessageMetadata(metadata.HeaderEndpoint, "test_endpoint"),
+			client.MessageMetadata(metadata.HeaderService, "test_service"),
+		}
+
+		msgs = append(msgs, c.NewMessage(topicTarget, req, opts...))
+	}
+
+	if err := c.BatchPublish(ctx, msgs); err != nil {
+		t.Fatal(err)
+	}
+
+	msv := micro.NewService(
+		micro.Server(s),
+		micro.Client(c),
+		micro.Broker(b),
+		micro.Context(ctx),
+		micro.Name("test_server"),
+		micro.Version("latest"))
+
+	if err := msv.Run(); err != nil {
+		t.Fatal(err)
+	}
+}