OpenTelemetry migration

.github/workflows/ci.yml

@@ -40,21 +40,23 @@ jobs:
         run: |
           sleep 30
           make ci
-      
+
       - name: Codecov
         uses: codecov/codecov-action@v4
         with:
           fail_ci_if_error: true # optional (default = false)
           files: ./coverage.txt
           name: codecov-umbrella # optional 
           token: ${{ secrets.CODECOV_TOKEN }} # required
-    
+
       - name: e2e
         run:  |
           go build -o service ./service/
           nohup ./service/service &
           go run client/main.go
         working-directory: ./examples
+        env:
+          OTEL_EXPORTER_OTLP_INSECURE : true
 
       - name: Stop dependencies
         run: make deps-stop

.gitignore

@@ -28,4 +28,5 @@ coverage.txt
 /cmd/patron/patron
 
 # tmp folder used in examples for storing logging, binaries and pids
-examples/tmp/
+examples/tmp/
+docker-compose/tempo-data/

.golangci.yml

@@ -30,13 +30,16 @@ linters:
   disable-all: true
   enable:
     - gofmt
+    - gosimple
     - gosec
     - unparam
     - goconst
     - prealloc
     - stylecheck
     - unconvert
+    - unused
     - staticcheck
+    - ineffassign
     - gosec
     - tparallel
     - whitespace

Makefile

@@ -1,22 +1,15 @@
-DOCKER = docker
+LINT_IMAGE = golangci/golangci-lint:v1.59.0
 
 default: test
 
 test: fmtcheck
 	go test ./... -cover -race -timeout 60s
 
-testint: fmtcheck  deps-start
-	go test ./... -race -cover -tags=integration -timeout 120s -count=1
+testint: fmtcheck
+	go test ./... -race -cover -tags=integration -timeout 300s -count=1
 
-cover: fmtcheck
-	go test ./... -coverpkg=./... -coverprofile=coverage.txt -tags=integration -covermode=atomic && \
-	go tool cover -func=coverage.txt && \
-	rm coverage.txt
-
-ci: 
-	go test ./... -race -cover -mod=vendor -coverprofile=coverage.txt -covermode=atomic -tags=integration && \
-	mv coverage.txt coverage.txt.tmp && \
-	cat coverage.txt.tmp | grep -v "/cmd/patron/" > coverage.txt
+ci: fmtcheck
+	go test `go list ./... | grep -v -e 'examples' -e 'encoding/protobuf/test'` -race -cover -coverprofile=coverage.txt -covermode=atomic -tags=integration 
 
 fmt:
 	go fmt ./...
@@ -25,19 +18,19 @@ fmtcheck:
 	@sh -c "'$(CURDIR)/script/gofmtcheck.sh'"
 
 lint: fmtcheck
-	$(DOCKER) run --env=GOFLAGS=-mod=vendor --rm -v $(CURDIR):/app -w /app golangci/golangci-lint:v1.57.2 golangci-lint -v run
+	docker run --env=GOFLAGS=-mod=vendor --rm -v $(CURDIR):/app -w /app $(LINT_IMAGE) golangci-lint -v run
 
 deeplint: fmtcheck
-	$(DOCKER) run --env=GOFLAGS=-mod=vendor --rm -v $(CURDIR):/app -w /app golangci/golangci-lint:v1.57.2 golangci-lint run --exclude-use-default=false --enable-all -D dupl --build-tags integration
+	docker run --env=GOFLAGS=-mod=vendor --rm -v $(CURDIR):/app -w /app $(LINT_IMAGE) golangci-lint run --exclude-use-default=false --enable-all -D dupl --build-tags integration
 
-modsync: fmtcheck
-	go mod tidy && 	go mod vendor
+example-service:
+	OTEL_EXPORTER_OTLP_INSECURE="true" go run examples/service/*.go
 
-examples:
-	$(MAKE) -C examples
+example-client:
+	OTEL_EXPORTER_OTLP_INSECURE="true" go run examples/client/main.go
 
 deps-start:
-	docker-compose up -d && sleep 10
+	docker-compose up -d
 
 deps-stop:
 	docker-compose down
@@ -47,4 +40,4 @@ deps-stop:
 # under parallel conditions.
 .NOTPARALLEL:
 
-.PHONY: default test testint cover coverci fmt fmtcheck lint deeplint ci modsync deps-start deps-stop
+.PHONY: default test testint cover coverci fmt fmtcheck lint deeplint ci modsync deps-start deps-stop example-service example-client

README.md

@@ -4,7 +4,7 @@ Patron is a framework for creating microservices, originally created by Sotiris
 
 `Patron` is french for `template` or `pattern`, but it means also `boss` which we found out later (no pun intended).
 
-The entry point of the framework is the `Service`. The `Service` uses `Components` to handle the processing of sync and async requests. The `Service` starts by default an `HTTP Component` which hosts the `/debug`, `/alive`, `/ready` and `/metrics` endpoints. Any other endpoints will be added to the default `HTTP Component` as `Routes`. Alongside `Routes` one can specify middleware functions to be applied ordered to all routes as `MiddlewareFunc`. The service sets up by default logging with `slog`, tracing and metrics with [Jaeger](https://www.jaegertracing.io/) and [prometheus](https://prometheus.io/).
+The entry point of the framework is the `Service`. The `Service` uses `Components` to handle the processing of sync and async requests. The `Service` starts by default an `HTTP Component` which hosts the `/debug`, `/alive`, `/ready` and `/metrics` endpoints. Any other endpoints will be added to the default `HTTP Component` as `Routes`. Alongside `Routes` one can specify middleware functions to be applied ordered to all routes as `MiddlewareFunc`. The service sets up by default logging with `slog`, tracing and metrics with [OpenTelemetry](https://opentelemetry.io).
 
 `Patron` provides abstractions for the following functionality of the framework:
 

cache/lru/lru.go

@@ -5,29 +5,44 @@ import (
 	"context"
 
 	"github.com/beatlabs/patron/cache"
-	"github.com/hashicorp/golang-lru"
+	lru "github.com/hashicorp/golang-lru"
+	"go.opentelemetry.io/otel/attribute"
 )
 
-var _ cache.Cache = &Cache{}
+var (
+	_            cache.Cache = &Cache{}
+	lruAttribute             = attribute.String("cache.type", "lru")
+)
 
 // Cache encapsulates a thread-safe fixed size LRU cache.
 type Cache struct {
-	cache *lru.Cache
+	cache            *lru.Cache
+	useCaseAttribute attribute.KeyValue
 }
 
 // New returns a new LRU cache that can hold 'size' number of keys at a time.
-func New(size int) (*Cache, error) {
-	cache, err := lru.New(size)
+func New(size int, useCase string) (*Cache, error) {
+	cache.SetupMetricsOnce()
+	chc, err := lru.New(size)
 	if err != nil {
 		return nil, err
 	}
-	return &Cache{cache: cache}, nil
+
+	return &Cache{
+		cache:            chc,
+		useCaseAttribute: cache.UseCaseAttribute(useCase),
+	}, nil
 }
 
 // Get executes a lookup and returns whether a key exists in the cache along with its value.
-func (c *Cache) Get(_ context.Context, key string) (interface{}, bool, error) {
+func (c *Cache) Get(ctx context.Context, key string) (interface{}, bool, error) {
 	value, ok := c.cache.Get(key)
-	return value, ok, nil
+	if !ok {
+		cache.ObserveMiss(ctx, lruAttribute, c.useCaseAttribute)
+		return nil, false, nil
+	}
+	cache.ObserveHit(ctx, lruAttribute, c.useCaseAttribute)
+	return value, true, nil
 }
 
 // Purge evicts all keys present in the cache.

cache/lru/lru_test.go

@@ -10,9 +10,9 @@ import (
 func TestNew(t *testing.T) {
 	tests := []struct {
 		name    string
+		err     string
 		size    int
 		wantErr bool
-		err     string
 	}{
 		{name: "negative size", size: -1, wantErr: true, err: "must provide a positive size"},
 		{name: "zero size", size: 0, wantErr: true, err: "must provide a positive size"},
@@ -21,7 +21,7 @@ func TestNew(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c, err := New(tt.size)
+			c, err := New(tt.size, "test")
 			if tt.wantErr {
 				assert.Nil(t, c)
 				assert.EqualError(t, err, tt.err)
@@ -34,7 +34,7 @@ func TestNew(t *testing.T) {
 }
 
 func TestCacheOperations(t *testing.T) {
-	c, err := New(10)
+	c, err := New(10, "test")
 	assert.NotNil(t, c)
 	assert.NoError(t, err)
 

cache/metric.go

@@ -0,0 +1,43 @@
+package cache
+
+import (
+	"context"
+	"sync"
+
+	patronmetric "github.com/beatlabs/patron/observability/metric"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/metric"
+)
+
+const packageName = "cache"
+
+var (
+	cashHitAttribute  = attribute.String("cache.status", "hit")
+	cashMissAttribute = attribute.String("cache.status", "miss")
+	cacheCounter      metric.Int64Counter
+	cacheOnce         sync.Once
+)
+
+// SetupMetricsOnce initializes the cache counter.
+func SetupMetricsOnce() {
+	cacheOnce.Do(func() {
+		cacheCounter = patronmetric.Int64Counter(packageName, "cache.counter", "Number of cache calls.", "1")
+	})
+}
+
+// UseCaseAttribute returns an attribute.KeyValue with the use case.
+func UseCaseAttribute(useCase string) attribute.KeyValue {
+	return attribute.String("cache.use_case", useCase)
+}
+
+// ObserveHit increments the cache hit counter.
+func ObserveHit(ctx context.Context, attrs ...attribute.KeyValue) {
+	attrs = append(attrs, cashHitAttribute)
+	cacheCounter.Add(ctx, 1, metric.WithAttributes(attrs...))
+}
+
+// ObserveMiss increments the cache miss counter.
+func ObserveMiss(ctx context.Context, attrs ...attribute.KeyValue) {
+	attrs = append(attrs, cashMissAttribute)
+	cacheCounter.Add(ctx, 1, metric.WithAttributes(attrs...))
+}

cache/metric_test.go

@@ -0,0 +1,48 @@
+package cache
+
+import (
+	"context"
+	"log"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	metricsdk "go.opentelemetry.io/otel/sdk/metric"
+	"go.opentelemetry.io/otel/sdk/metric/metricdata"
+)
+
+func TestUseCaseAttribute(t *testing.T) {
+	assert.Equal(t, attribute.String("cache.use_case", "test"), UseCaseAttribute("test"))
+}
+
+func TestSetupAndUseMetrics(t *testing.T) {
+	SetupMetricsOnce()
+
+	read := metricsdk.NewManualReader()
+	provider := metricsdk.NewMeterProvider(metricsdk.WithReader(read))
+	defer func() {
+		err := provider.Shutdown(context.Background())
+		if err != nil {
+			log.Fatal(err)
+		}
+	}()
+
+	otel.SetMeterProvider(provider)
+
+	assert.NotNil(t, cacheCounter)
+
+	ObserveHit(context.Background(), attribute.String("test", "test"))
+
+	collectedMetrics := &metricdata.ResourceMetrics{}
+	assert.NoError(t, read.Collect(context.Background(), collectedMetrics))
+
+	assert.Equal(t, 1, len(collectedMetrics.ScopeMetrics))
+
+	ObserveMiss(context.Background(), attribute.String("test", "test"))
+
+	collectedMetrics = &metricdata.ResourceMetrics{}
+	assert.NoError(t, read.Collect(context.Background(), collectedMetrics))
+
+	assert.Equal(t, 1, len(collectedMetrics.ScopeMetrics))
+}

cache/redis/integration_test.go

@@ -1,5 +1,4 @@
 //go:build integration
-// +build integration
 
 package redis
 
@@ -8,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/redis/go-redis/v9"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -17,11 +17,7 @@ const (
 )
 
 func TestCache(t *testing.T) {
-	cache, err := New(Options{
-		Addr:     dsn,
-		Password: "", // no password set
-		DB:       0,  // use default DB
-	})
+	cache, err := New(&redis.Options{Addr: dsn}, "test")
 	require.NoError(t, err)
 
 	key1 := "key1"

cache/redis/redis.go

@@ -7,34 +7,46 @@
 	"time"
 
 	"github.com/beatlabs/patron/cache"
-	"github.com/beatlabs/patron/client/redis"
+	patronredis "github.com/beatlabs/patron/client/redis"
+	"github.com/redis/go-redis/v9"
+	"go.opentelemetry.io/otel/attribute"
 )
 
-var _ cache.TTLCache = &Cache{}
+var (
+	_              cache.TTLCache = &Cache{}
+	redisAttribute                = attribute.String("cache.type", "redis")
+)
 
 // Cache encapsulates a Redis-based caching mechanism.
 type Cache struct {
-	rdb redis.Client
+	rdb              *redis.Client
+	useCaseAttribute attribute.KeyValue
 }
 
-// Options exposes the struct from go-redis package.
-type Options redis.Options
-
 // New creates a cache returns a new Redis client that will be used as the cache store.
-func New(opt Options) (*Cache, error) {
-	redisDB := redis.New(redis.Options(opt))
-	return &Cache{rdb: redisDB}, nil
+func New(opt *redis.Options, useCase string) (*Cache, error) {
+	cache.SetupMetricsOnce()
+	redisDB, err := patronredis.New(opt)
+	if err != nil {
+		return nil, err
+	}
+	return &Cache{
+		rdb:              redisDB,
+		useCaseAttribute: cache.UseCaseAttribute(useCase),
+	}, nil
 }
 
 // Get executes a lookup and returns whether a key exists in the cache along with its value.
 func (c *Cache) Get(ctx context.Context, key string) (interface{}, bool, error) {
 	res, err := c.rdb.Do(ctx, "get", key).Result()
 	if err != nil {
 		if errors.Is(err, redis.Nil) { // cache miss
+			cache.ObserveMiss(ctx, redisAttribute, c.useCaseAttribute)
 			return nil, false, nil
 		}
 		return nil, false, err
 	}
+	cache.ObserveHit(ctx, redisAttribute, c.useCaseAttribute)
 	return res, true, nil
 }