Add autoconfiguration for OTEL and resolve TODOs for metrics

internal/mojang/batch_uuids_provider.go

@@ -111,7 +111,7 @@ func (p *BatchUuidsProvider) fireRequest() {
 	for {
 		foundJobs, left := p.queue.Dequeue(n)
 		for i := range foundJobs {
-			p.metrics.QueueTime.Record(reqCtx, float64(time.Since(foundJobs[i].QueuingTime)))
+			p.metrics.QueueTime.Record(reqCtx, float64(time.Since(foundJobs[i].QueuingTime).Milliseconds()))
 			if foundJobs[i].Ctx.Err() != nil {
 				// If the job context has already ended, its result will be returned in the GetUuid method
 				close(foundJobs[i].ResultChan)
@@ -139,6 +139,7 @@ func (p *BatchUuidsProvider) fireRequest() {
 		usernames[i] = job.Username
 	}
 
+	p.metrics.Requests.Add(reqCtx, 1)
 	p.metrics.BatchSize.Record(reqCtx, int64(len(usernames)))
 
 	profiles, err := p.UsernamesToUuidsEndpoint(reqCtx, usernames)
@@ -165,9 +166,23 @@ func newBatchUuidsProviderMetrics(meter metric.Meter, queue *utils.Queue[*job])
 	m := &batchUuidsProviderMetrics{}
 	var errors, err error
 
+	m.Requests, err = meter.Int64Counter(
+		"uuids.batch.request.sent",
+		metric.WithDescription("Number of UUIDs requests sent to Mojang API"),
+		metric.WithUnit("1"),
+	)
+	errors = multierr.Append(errors, err)
+
+	m.BatchSize, err = meter.Int64Histogram(
+		"uuids.batch.request.batch_size",
+		metric.WithDescription("The number of usernames in the query"),
+		metric.WithUnit("1"),
+	)
+	errors = multierr.Append(errors, err)
+
 	m.QueueLength, err = meter.Int64ObservableGauge(
-		"queue.length",             // TODO: look for better naming
-		metric.WithDescription(""), // TODO: description
+		"uuids.batch.queue.length",
+		metric.WithDescription("Number of tasks in the queue waiting for execution"),
 		metric.WithInt64Callback(func(_ context.Context, o metric.Int64Observer) error {
 			o.Observe(int64(queue.Len()))
 			return nil
@@ -176,23 +191,18 @@ func newBatchUuidsProviderMetrics(meter metric.Meter, queue *utils.Queue[*job])
 	errors = multierr.Append(errors, err)
 
 	m.QueueTime, err = meter.Float64Histogram(
-		"queue.duration",
-		metric.WithDescription(""), // TODO: description
+		"uuids.batch.queue.lag",
+		metric.WithDescription("Lag between placing a job in the queue and starting its processing"),
 		metric.WithUnit("ms"),
 	)
-
-	m.BatchSize, err = meter.Int64Histogram(
-		"batch.size",
-		metric.WithDescription(""), // TODO: write description
-		metric.WithUnit("1"),
-	)
 	errors = multierr.Append(errors, err)
 
 	return m, errors
 }
 
 type batchUuidsProviderMetrics struct {
+	Requests    metric.Int64Counter
+	BatchSize   metric.Int64Histogram
 	QueueLength metric.Int64ObservableGauge
 	QueueTime   metric.Float64Histogram
-	BatchSize   metric.Int64Histogram
 }

internal/mojang/client.go

@@ -77,7 +77,6 @@ func (c *MojangApi) UsernamesToUuids(ctx context.Context, usernames []string) ([
 // Obtains textures information for provided uuid
 // See https://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape
 func (c *MojangApi) UuidToTextures(ctx context.Context, uuid string, signed bool) (*ProfileResponse, error) {
-	// TODO: normalize request url for tracing
 	normalizedUuid := strings.ReplaceAll(uuid, "-", "")
 	url := c.profileUrl + normalizedUuid
 	if signed {

internal/mojang/provider.go

@@ -59,7 +59,13 @@ func (p *MojangTexturesProvider) GetForUsername(ctx context.Context, username st
 	username = strings.ToLower(username)
 
 	result, err, shared := p.group.Do(username, func() (*ProfileResponse, error) {
-		profile, err := p.UuidsProvider.GetUuid(ctx, username)
+		var profile *ProfileInfo
+		var textures *ProfileResponse
+		var err error
+
+		defer p.recordMetrics(ctx, profile, textures, err)
+
+		profile, err = p.UuidsProvider.GetUuid(ctx, username)
 		if err != nil {
 			return nil, err
 		}
@@ -68,28 +74,36 @@ func (p *MojangTexturesProvider) GetForUsername(ctx context.Context, username st
 			return nil, nil
 		}
 
-		return p.TexturesProvider.GetTextures(ctx, profile.Id)
+		textures, err = p.TexturesProvider.GetTextures(ctx, profile.Id)
+
+		return textures, err
 	})
 
-	p.recordMetrics(ctx, shared, result, err)
-
-	return result, err
-}
-
-func (p *MojangTexturesProvider) recordMetrics(ctx context.Context, shared bool, result *ProfileResponse, err error) {
 	if shared {
 		p.metrics.Shared.Add(ctx, 1)
 	}
 
+	return result, err
+}
+
+func (p *MojangTexturesProvider) recordMetrics(ctx context.Context, profile *ProfileInfo, textures *ProfileResponse, err error) {
 	if err != nil {
 		p.metrics.Failed.Add(ctx, 1)
 		return
 	}
 
-	if result != nil {
-		p.metrics.Found.Add(ctx, 1)
+	if profile == nil {
+		p.metrics.UsernameMissed.Add(ctx, 1)
+		p.metrics.TextureMissed.Add(ctx, 1)
+
+		return
+	}
+
+	p.metrics.UsernameFound.Add(ctx, 1)
+	if textures != nil {
+		p.metrics.TextureFound.Add(ctx, 1)
 	} else {
-		p.metrics.Missed.Add(ctx, 1)
+		p.metrics.TextureMissed.Add(ctx, 1)
 	}
 }
 
@@ -104,27 +118,45 @@ func newProviderMetrics(meter metric.Meter) (*providerMetrics, error) {
 	m := &providerMetrics{}
 	var errors, err error
 
-	m.Found, err = meter.Int64Counter(
-		"results.found",
-		metric.WithDescription(""), // TODO: description
+	m.UsernameFound, err = meter.Int64Counter(
+		"provider.username_found",
+		metric.WithDescription("Number of queries for which username was found"),
+		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)
 
-	m.Missed, err = meter.Int64Counter(
-		"results.missed",
-		metric.WithDescription(""), // TODO: description
+	m.UsernameMissed, err = meter.Int64Counter(
+		"provider.username_missed",
+		metric.WithDescription("Number of queries for which username was not found"),
+		metric.WithUnit("1"),
+	)
+	errors = multierr.Append(errors, err)
+
+	m.TextureFound, err = meter.Int64Counter(
+		"provider.textures_found",
+		metric.WithDescription("Number of queries for which textures were successfully found"),
+		metric.WithUnit("1"),
+	)
+	errors = multierr.Append(errors, err)
+
+	m.TextureMissed, err = meter.Int64Counter(
+		"provider.textures_missed",
+		metric.WithDescription("Number of queries for which no textures were found"),
+		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)
 
 	m.Failed, err = meter.Int64Counter(
-		"results.failed",
-		metric.WithDescription(""), // TODO: description
+		"provider.failed",
+		metric.WithDescription("Number of requests that ended in an error"),
+		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)
 
 	m.Shared, err = meter.Int64Counter(
-		"singleflight.shared",
-		metric.WithDescription(""), // TODO: description
+		"provider.singleflight.shared",
+		metric.WithDescription("Number of requests that are already being processed in another thread"),
+		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)
 
@@ -132,8 +164,10 @@ func newProviderMetrics(meter metric.Meter) (*providerMetrics, error) {
 }
 
 type providerMetrics struct {
-	Found  metric.Int64Counter
-	Missed metric.Int64Counter
-	Failed metric.Int64Counter
-	Shared metric.Int64Counter
+	UsernameFound  metric.Int64Counter
+	UsernameMissed metric.Int64Counter
+	TextureFound   metric.Int64Counter
+	TextureMissed  metric.Int64Counter
+	Failed         metric.Int64Counter
+	Shared         metric.Int64Counter
 }

internal/mojang/textures_provider.go

@@ -100,8 +100,8 @@ func newMojangApiTexturesProviderMetrics(meter metric.Meter) (*mojangApiTextures
 	var errors, err error
 
 	m.Requests, err = meter.Int64Counter(
-		"textures.requests",
-		metric.WithDescription(""), // TODO: write description
+		"textures.request.sent",
+		metric.WithDescription("Number of textures requests sent to Mojang API"),
 		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)
@@ -119,14 +119,14 @@ func newTexturesProviderWithInMemoryCacheMetrics(meter metric.Meter) (*texturesP
 
 	m.Hits, err = meter.Int64Counter(
 		"textures.cache.hit",
-		metric.WithDescription(""), // TODO: write description
+		metric.WithDescription("Number of Mojang textures found in the local cache"),
 		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)
 
 	m.Misses, err = meter.Int64Counter(
 		"textures.cache.miss",
-		metric.WithDescription(""), // TODO: write description
+		metric.WithDescription("Number of Mojang textures missing from local cache"),
 		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)

internal/mojang/uuids_provider.go

@@ -89,14 +89,14 @@ func newUuidsProviderWithCacheMetrics(meter metric.Meter) (*uuidsProviderWithCac
 
 	m.Hits, err = meter.Int64Counter(
 		"uuids.cache.hit",
-		metric.WithDescription(""), // TODO: write description
+		metric.WithDescription("Number of Mojang UUIDs found in the local cache"),
 		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)
 
 	m.Misses, err = meter.Int64Counter(
 		"uuids.cache.miss",
-		metric.WithDescription(""), // TODO: write description
+		metric.WithDescription("Number of Mojang UUIDs missing from local cache"),
 		metric.WithUnit("1"),
 	)
 	errors = multierr.Append(errors, err)