From 2acfd0aa8f1a24123be749d44fea33dc8a11d285 Mon Sep 17 00:00:00 2001
From: ensiouel <ensiouel@gmail.com>
Date: Tue, 26 Dec 2023 15:29:19 +0300
Subject: [PATCH] Revert "fix type telemetry template"
This reverts commit 4a4c3f1c3ae7400a86169e4192230a864d663acd.
---
assets/templates/middleware/telemetry | 40 +-
images/middleware/telemetry_middleware.go | 40 +-
pkg/cache/telemetry_middleware.go | 2 +-
.../middleware/telemetry_middleware.go | 184 +++----
.../middleware/telemetry_middleware.go | 136 +++---
.../middleware/telemetry_middleware.go | 184 +++----
.../middleware/telemetry_middleware.go | 208 ++++----
.../middleware/telemetry_middleware.go | 208 ++++----
pkg/files/middleware/telemetry_middleware.go | 184 +++----
.../middleware/telemetry_middleware.go | 136 +++---
pkg/items/middleware/telemetry_middleware.go | 448 +++++++++---------
.../middleware/telemetry_middleware.go | 88 ++--
.../middleware/telemetry_middleware.go | 160 +++----
.../middleware/telemetry_middleware.go | 136 +++---
.../middleware/telemetry_middleware.go | 64 +--
pkg/roles/middleware/telemetry_middleware.go | 136 +++---
pkg/spaces/middleware/telemetry_middleware.go | 256 +++++-----
{telemetry => pkg/telemetry}/metrics/cache.go | 0
.../telemetry}/metrics/request.go | 0
pkg/users/middleware/telemetry_middleware.go | 160 +++----
20 files changed, 1385 insertions(+), 1385 deletions(-)
rename {telemetry => pkg/telemetry}/metrics/cache.go (100%)
rename {telemetry => pkg/telemetry}/metrics/request.go (100%)
diff --git a/assets/templates/middleware/telemetry b/assets/templates/middleware/telemetry
index 57be255c..554dee3f 100644
--- a/assets/templates/middleware/telemetry
+++ b/assets/templates/middleware/telemetry
@@ -2,7 +2,7 @@ import (
"context"
"time"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -15,61 +15,61 @@ import (
// {{$decorator}} implements {{.Interface.Type}} interface instrumented with opentracing spans
type {{$decorator}} struct {
{{.Interface.Type}}
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// {{$funcName}} returns {{$decorator}}
-func {{$funcName}} (base {{.Interface.Type}}, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) {{$decorator}} {
+func {{$funcName}} (base {{.Interface.Type}}, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) {{$decorator}} {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := {{$decorator}} {
+ d := {{$decorator}} {
{{.Interface.Name}}: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
{{range $method := .Interface.Methods}}
{{if $method.AcceptsContext}}
// {{$method.Name}} implements {{$.Interface.Type}}
-func (m {{$decorator}}) {{$method.Declaration}} {
+func (_d {{$decorator}}) {{$method.Declaration}} {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "{{ $.Interface.Name }}"),
attribute.String("method", "{{ $method.Name }}"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "{{$.Interface.Name}}.{{$method.Name}}")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "{{$.Interface.Name}}.{{$method.Name}}")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, {{$method.ParamsMap}}, {{$method.ResultsMap}})
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, {{$method.ParamsMap}}, {{$method.ResultsMap}})
}{{- if $method.ReturnsError}} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
{{end}}
- span.End()
+ _span.End()
}()
- {{$method.Pass (printf "m.%s." $.Interface.Name) }}
+ {{$method.Pass (printf "_d.%s." $.Interface.Name) }}
}
{{end}}
{{end}}
\ No newline at end of file
diff --git a/images/middleware/telemetry_middleware.go b/images/middleware/telemetry_middleware.go
index 1a450dc8..bb5d217a 100644
--- a/images/middleware/telemetry_middleware.go
+++ b/images/middleware/telemetry_middleware.go
@@ -12,7 +12,7 @@ import (
"git.perx.ru/perxis/perxis-go/images"
"git.perx.ru/perxis/perxis-go/pkg/files"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -22,62 +22,62 @@ import (
// telemetryMiddleware implements images.Images interface instrumented with opentracing spans
type telemetryMiddleware struct {
images.Images
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base images.Images, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base images.Images, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Images: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Get implements images.Images
-func (m telemetryMiddleware) Get(ctx context.Context, source *files.File, opts *images.GetOptions) (result *files.File, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, source *files.File, opts *images.GetOptions) (result *files.File, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Images"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Images.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Images.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"source": source,
"opts": opts}, map[string]interface{}{
"result": result,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Images.Get(ctx, source, opts)
+ return _d.Images.Get(ctx, source, opts)
}
diff --git a/pkg/cache/telemetry_middleware.go b/pkg/cache/telemetry_middleware.go
index cd6cbb99..5c22fcce 100644
--- a/pkg/cache/telemetry_middleware.go
+++ b/pkg/cache/telemetry_middleware.go
@@ -3,7 +3,7 @@ package cache
import (
"context"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
)
diff --git a/pkg/clients/middleware/telemetry_middleware.go b/pkg/clients/middleware/telemetry_middleware.go
index d5b3e54e..35782f7f 100644
--- a/pkg/clients/middleware/telemetry_middleware.go
+++ b/pkg/clients/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/clients"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,267 +21,267 @@ import (
// telemetryMiddleware implements clients.Clients interface instrumented with opentracing spans
type telemetryMiddleware struct {
clients.Clients
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base clients.Clients, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base clients.Clients, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Clients: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Create implements clients.Clients
-func (m telemetryMiddleware) Create(ctx context.Context, client *clients.Client) (created *clients.Client, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, client *clients.Client) (created *clients.Client, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Clients"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Clients.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"client": client}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Clients.Create(ctx, client)
+ return _d.Clients.Create(ctx, client)
}
// Delete implements clients.Clients
-func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, id string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, spaceId string, id string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Clients"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Clients.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"id": id}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Clients.Delete(ctx, spaceId, id)
+ return _d.Clients.Delete(ctx, spaceId, id)
}
// Enable implements clients.Clients
-func (m telemetryMiddleware) Enable(ctx context.Context, spaceId string, id string, enable bool) (err error) {
+func (_d telemetryMiddleware) Enable(ctx context.Context, spaceId string, id string, enable bool) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Clients"),
attribute.String("method", "Enable"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Enable")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Clients.Enable")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"id": id,
"enable": enable}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Clients.Enable(ctx, spaceId, id, enable)
+ return _d.Clients.Enable(ctx, spaceId, id, enable)
}
// Get implements clients.Clients
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, id string) (client *clients.Client, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string, id string) (client *clients.Client, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Clients"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Clients.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"id": id}, map[string]interface{}{
"client": client,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Clients.Get(ctx, spaceId, id)
+ return _d.Clients.Get(ctx, spaceId, id)
}
// GetBy implements clients.Clients
-func (m telemetryMiddleware) GetBy(ctx context.Context, spaceId string, params *clients.GetByParams) (client *clients.Client, err error) {
+func (_d telemetryMiddleware) GetBy(ctx context.Context, spaceId string, params *clients.GetByParams) (client *clients.Client, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Clients"),
attribute.String("method", "GetBy"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.GetBy")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Clients.GetBy")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"params": params}, map[string]interface{}{
"client": client,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Clients.GetBy(ctx, spaceId, params)
+ return _d.Clients.GetBy(ctx, spaceId, params)
}
// List implements clients.Clients
-func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (clients []*clients.Client, err error) {
+func (_d telemetryMiddleware) List(ctx context.Context, spaceId string) (clients []*clients.Client, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Clients"),
attribute.String("method", "List"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.List")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Clients.List")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"clients": clients,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Clients.List(ctx, spaceId)
+ return _d.Clients.List(ctx, spaceId)
}
// Update implements clients.Clients
-func (m telemetryMiddleware) Update(ctx context.Context, client *clients.Client) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, client *clients.Client) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Clients"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Clients.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"client": client}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Clients.Update(ctx, client)
+ return _d.Clients.Update(ctx, client)
}
diff --git a/pkg/collaborators/middleware/telemetry_middleware.go b/pkg/collaborators/middleware/telemetry_middleware.go
index 457f0995..6ad967e4 100644
--- a/pkg/collaborators/middleware/telemetry_middleware.go
+++ b/pkg/collaborators/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/collaborators"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,199 +21,199 @@ import (
// telemetryMiddleware implements collaborators.Collaborators interface instrumented with opentracing spans
type telemetryMiddleware struct {
collaborators.Collaborators
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base collaborators.Collaborators, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base collaborators.Collaborators, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Collaborators: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Get implements collaborators.Collaborators
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, subject string) (role string, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string, subject string) (role string, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collaborators"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collaborators.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"subject": subject}, map[string]interface{}{
"role": role,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collaborators.Get(ctx, spaceId, subject)
+ return _d.Collaborators.Get(ctx, spaceId, subject)
}
// ListCollaborators implements collaborators.Collaborators
-func (m telemetryMiddleware) ListCollaborators(ctx context.Context, spaceId string) (collaborators []*collaborators.Collaborator, err error) {
+func (_d telemetryMiddleware) ListCollaborators(ctx context.Context, spaceId string) (collaborators []*collaborators.Collaborator, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collaborators"),
attribute.String("method", "ListCollaborators"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.ListCollaborators")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collaborators.ListCollaborators")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"collaborators": collaborators,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collaborators.ListCollaborators(ctx, spaceId)
+ return _d.Collaborators.ListCollaborators(ctx, spaceId)
}
// ListSpaces implements collaborators.Collaborators
-func (m telemetryMiddleware) ListSpaces(ctx context.Context, subject string) (spaces []*collaborators.Collaborator, err error) {
+func (_d telemetryMiddleware) ListSpaces(ctx context.Context, subject string) (spaces []*collaborators.Collaborator, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collaborators"),
attribute.String("method", "ListSpaces"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.ListSpaces")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collaborators.ListSpaces")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"subject": subject}, map[string]interface{}{
"spaces": spaces,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collaborators.ListSpaces(ctx, subject)
+ return _d.Collaborators.ListSpaces(ctx, subject)
}
// Remove implements collaborators.Collaborators
-func (m telemetryMiddleware) Remove(ctx context.Context, spaceId string, subject string) (err error) {
+func (_d telemetryMiddleware) Remove(ctx context.Context, spaceId string, subject string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collaborators"),
attribute.String("method", "Remove"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.Remove")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collaborators.Remove")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"subject": subject}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collaborators.Remove(ctx, spaceId, subject)
+ return _d.Collaborators.Remove(ctx, spaceId, subject)
}
// Set implements collaborators.Collaborators
-func (m telemetryMiddleware) Set(ctx context.Context, spaceId string, subject string, role string) (err error) {
+func (_d telemetryMiddleware) Set(ctx context.Context, spaceId string, subject string, role string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collaborators"),
attribute.String("method", "Set"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.Set")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collaborators.Set")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"subject": subject,
"role": role}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collaborators.Set(ctx, spaceId, subject, role)
+ return _d.Collaborators.Set(ctx, spaceId, subject, role)
}
diff --git a/pkg/collections/middleware/telemetry_middleware.go b/pkg/collections/middleware/telemetry_middleware.go
index cfaa9355..bd4f4c90 100644
--- a/pkg/collections/middleware/telemetry_middleware.go
+++ b/pkg/collections/middleware/telemetry_middleware.go
@@ -12,7 +12,7 @@ import (
"git.perx.ru/perxis/perxis-go/pkg/collections"
"git.perx.ru/perxis/perxis-go/pkg/schema"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -22,117 +22,117 @@ import (
// telemetryMiddleware implements collections.Collections interface instrumented with opentracing spans
type telemetryMiddleware struct {
collections.Collections
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base collections.Collections, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base collections.Collections, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Collections: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Create implements collections.Collections
-func (m telemetryMiddleware) Create(ctx context.Context, collection *collections.Collection) (created *collections.Collection, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, collection *collections.Collection) (created *collections.Collection, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collections"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collections.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"collection": collection}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collections.Create(ctx, collection)
+ return _d.Collections.Create(ctx, collection)
}
// Delete implements collections.Collections
-func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, envId string, collectionId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, spaceId string, envId string, collectionId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collections"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collections.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
"collectionId": collectionId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collections.Delete(ctx, spaceId, envId, collectionId)
+ return _d.Collections.Delete(ctx, spaceId, envId, collectionId)
}
// Get implements collections.Collections
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, options ...*collections.GetOptions) (collection *collections.Collection, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, options ...*collections.GetOptions) (collection *collections.Collection, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collections"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collections.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -141,35 +141,35 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId stri
"collection": collection,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collections.Get(ctx, spaceId, envId, collectionId, options...)
+ return _d.Collections.Get(ctx, spaceId, envId, collectionId, options...)
}
// List implements collections.Collections
-func (m telemetryMiddleware) List(ctx context.Context, spaceId string, envId string, filter *collections.Filter) (collections []*collections.Collection, err error) {
+func (_d telemetryMiddleware) List(ctx context.Context, spaceId string, envId string, filter *collections.Filter) (collections []*collections.Collection, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collections"),
attribute.String("method", "List"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.List")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collections.List")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -177,35 +177,35 @@ func (m telemetryMiddleware) List(ctx context.Context, spaceId string, envId str
"collections": collections,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collections.List(ctx, spaceId, envId, filter)
+ return _d.Collections.List(ctx, spaceId, envId, filter)
}
// SetSchema implements collections.Collections
-func (m telemetryMiddleware) SetSchema(ctx context.Context, spaceId string, envId string, collectionId string, schema *schema.Schema) (err error) {
+func (_d telemetryMiddleware) SetSchema(ctx context.Context, spaceId string, envId string, collectionId string, schema *schema.Schema) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collections"),
attribute.String("method", "SetSchema"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.SetSchema")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collections.SetSchema")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -213,35 +213,35 @@ func (m telemetryMiddleware) SetSchema(ctx context.Context, spaceId string, envI
"schema": schema}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collections.SetSchema(ctx, spaceId, envId, collectionId, schema)
+ return _d.Collections.SetSchema(ctx, spaceId, envId, collectionId, schema)
}
// SetState implements collections.Collections
-func (m telemetryMiddleware) SetState(ctx context.Context, spaceId string, envId string, collectionId string, state *collections.StateInfo) (err error) {
+func (_d telemetryMiddleware) SetState(ctx context.Context, spaceId string, envId string, collectionId string, state *collections.StateInfo) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collections"),
attribute.String("method", "SetState"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.SetState")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collections.SetState")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -249,47 +249,47 @@ func (m telemetryMiddleware) SetState(ctx context.Context, spaceId string, envId
"state": state}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collections.SetState(ctx, spaceId, envId, collectionId, state)
+ return _d.Collections.SetState(ctx, spaceId, envId, collectionId, state)
}
// Update implements collections.Collections
-func (m telemetryMiddleware) Update(ctx context.Context, coll *collections.Collection) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, coll *collections.Collection) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Collections"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Collections.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"coll": coll}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Collections.Update(ctx, coll)
+ return _d.Collections.Update(ctx, coll)
}
diff --git a/pkg/delivery/middleware/telemetry_middleware.go b/pkg/delivery/middleware/telemetry_middleware.go
index cd7f5211..8252c536 100644
--- a/pkg/delivery/middleware/telemetry_middleware.go
+++ b/pkg/delivery/middleware/telemetry_middleware.go
@@ -15,7 +15,7 @@ import (
"git.perx.ru/perxis/perxis-go/pkg/environments"
"git.perx.ru/perxis/perxis-go/pkg/items"
"git.perx.ru/perxis/perxis-go/pkg/locales"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -25,48 +25,48 @@ import (
// telemetryMiddleware implements delivery.Delivery interface instrumented with opentracing spans
type telemetryMiddleware struct {
delivery.Delivery
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base delivery.Delivery, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base delivery.Delivery, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Delivery: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Aggregate implements delivery.Delivery
-func (m telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
+func (_d telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "Aggregate"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.Aggregate")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.Aggregate")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -76,35 +76,35 @@ func (m telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envI
"result": result,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
+ return _d.Delivery.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
}
// FindItems implements delivery.Delivery
-func (m telemetryMiddleware) FindItems(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindPublishedOptions) (items []*items.Item, total int, err error) {
+func (_d telemetryMiddleware) FindItems(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindPublishedOptions) (items []*items.Item, total int, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "FindItems"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.FindItems")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.FindItems")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -115,35 +115,35 @@ func (m telemetryMiddleware) FindItems(ctx context.Context, spaceId string, envI
"total": total,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.FindItems(ctx, spaceId, envId, collectionId, filter, options...)
+ return _d.Delivery.FindItems(ctx, spaceId, envId, collectionId, filter, options...)
}
// GetCollection implements delivery.Delivery
-func (m telemetryMiddleware) GetCollection(ctx context.Context, spaceId string, envId string, collectionId string) (collection *collections.Collection, err error) {
+func (_d telemetryMiddleware) GetCollection(ctx context.Context, spaceId string, envId string, collectionId string) (collection *collections.Collection, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "GetCollection"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.GetCollection")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.GetCollection")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -151,70 +151,70 @@ func (m telemetryMiddleware) GetCollection(ctx context.Context, spaceId string,
"collection": collection,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.GetCollection(ctx, spaceId, envId, collectionId)
+ return _d.Delivery.GetCollection(ctx, spaceId, envId, collectionId)
}
// GetEnvironment implements delivery.Delivery
-func (m telemetryMiddleware) GetEnvironment(ctx context.Context, spaceId string, envId string) (env *environments.Environment, err error) {
+func (_d telemetryMiddleware) GetEnvironment(ctx context.Context, spaceId string, envId string) (env *environments.Environment, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "GetEnvironment"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.GetEnvironment")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.GetEnvironment")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId}, map[string]interface{}{
"env": env,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.GetEnvironment(ctx, spaceId, envId)
+ return _d.Delivery.GetEnvironment(ctx, spaceId, envId)
}
// GetItem implements delivery.Delivery
-func (m telemetryMiddleware) GetItem(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetPublishedOptions) (item *items.Item, err error) {
+func (_d telemetryMiddleware) GetItem(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetPublishedOptions) (item *items.Item, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "GetItem"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.GetItem")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.GetItem")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -224,117 +224,117 @@ func (m telemetryMiddleware) GetItem(ctx context.Context, spaceId string, envId
"item": item,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.GetItem(ctx, spaceId, envId, collectionId, itemId, options...)
+ return _d.Delivery.GetItem(ctx, spaceId, envId, collectionId, itemId, options...)
}
// ListCollections implements delivery.Delivery
-func (m telemetryMiddleware) ListCollections(ctx context.Context, spaceId string, envId string) (collections []*collections.Collection, err error) {
+func (_d telemetryMiddleware) ListCollections(ctx context.Context, spaceId string, envId string) (collections []*collections.Collection, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "ListCollections"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.ListCollections")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.ListCollections")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId}, map[string]interface{}{
"collections": collections,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.ListCollections(ctx, spaceId, envId)
+ return _d.Delivery.ListCollections(ctx, spaceId, envId)
}
// ListEnvironments implements delivery.Delivery
-func (m telemetryMiddleware) ListEnvironments(ctx context.Context, spaceId string) (envs []*environments.Environment, err error) {
+func (_d telemetryMiddleware) ListEnvironments(ctx context.Context, spaceId string) (envs []*environments.Environment, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "ListEnvironments"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.ListEnvironments")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.ListEnvironments")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"envs": envs,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.ListEnvironments(ctx, spaceId)
+ return _d.Delivery.ListEnvironments(ctx, spaceId)
}
// ListLocales implements delivery.Delivery
-func (m telemetryMiddleware) ListLocales(ctx context.Context, spaceId string) (locales []*locales.Locale, err error) {
+func (_d telemetryMiddleware) ListLocales(ctx context.Context, spaceId string) (locales []*locales.Locale, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Delivery"),
attribute.String("method", "ListLocales"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.ListLocales")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Delivery.ListLocales")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"locales": locales,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Delivery.ListLocales(ctx, spaceId)
+ return _d.Delivery.ListLocales(ctx, spaceId)
}
diff --git a/pkg/environments/middleware/telemetry_middleware.go b/pkg/environments/middleware/telemetry_middleware.go
index 7d21b264..4a46b9aa 100644
--- a/pkg/environments/middleware/telemetry_middleware.go
+++ b/pkg/environments/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/environments"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,302 +21,302 @@ import (
// telemetryMiddleware implements environments.Environments interface instrumented with opentracing spans
type telemetryMiddleware struct {
environments.Environments
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base environments.Environments, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base environments.Environments, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Environments: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Create implements environments.Environments
-func (m telemetryMiddleware) Create(ctx context.Context, env *environments.Environment) (created *environments.Environment, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, env *environments.Environment) (created *environments.Environment, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"env": env}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.Create(ctx, env)
+ return _d.Environments.Create(ctx, env)
}
// Delete implements environments.Environments
-func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, envId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, spaceId string, envId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.Delete(ctx, spaceId, envId)
+ return _d.Environments.Delete(ctx, spaceId, envId)
}
// Get implements environments.Environments
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string) (env *environments.Environment, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string) (env *environments.Environment, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId}, map[string]interface{}{
"env": env,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.Get(ctx, spaceId, envId)
+ return _d.Environments.Get(ctx, spaceId, envId)
}
// List implements environments.Environments
-func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (envs []*environments.Environment, err error) {
+func (_d telemetryMiddleware) List(ctx context.Context, spaceId string) (envs []*environments.Environment, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "List"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.List")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.List")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"envs": envs,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.List(ctx, spaceId)
+ return _d.Environments.List(ctx, spaceId)
}
// Migrate implements environments.Environments
-func (m telemetryMiddleware) Migrate(ctx context.Context, spaceId string, envId string, options ...*environments.MigrateOptions) (err error) {
+func (_d telemetryMiddleware) Migrate(ctx context.Context, spaceId string, envId string, options ...*environments.MigrateOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "Migrate"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Migrate")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.Migrate")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.Migrate(ctx, spaceId, envId, options...)
+ return _d.Environments.Migrate(ctx, spaceId, envId, options...)
}
// RemoveAlias implements environments.Environments
-func (m telemetryMiddleware) RemoveAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
+func (_d telemetryMiddleware) RemoveAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "RemoveAlias"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.RemoveAlias")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.RemoveAlias")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
"alias": alias}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.RemoveAlias(ctx, spaceId, envId, alias)
+ return _d.Environments.RemoveAlias(ctx, spaceId, envId, alias)
}
// SetAlias implements environments.Environments
-func (m telemetryMiddleware) SetAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
+func (_d telemetryMiddleware) SetAlias(ctx context.Context, spaceId string, envId string, alias string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "SetAlias"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.SetAlias")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.SetAlias")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
"alias": alias}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.SetAlias(ctx, spaceId, envId, alias)
+ return _d.Environments.SetAlias(ctx, spaceId, envId, alias)
}
// Update implements environments.Environments
-func (m telemetryMiddleware) Update(ctx context.Context, env *environments.Environment) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, env *environments.Environment) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Environments"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Environments.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"env": env}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Environments.Update(ctx, env)
+ return _d.Environments.Update(ctx, env)
}
diff --git a/pkg/files/middleware/telemetry_middleware.go b/pkg/files/middleware/telemetry_middleware.go
index a65a52a5..d282c065 100644
--- a/pkg/files/middleware/telemetry_middleware.go
+++ b/pkg/files/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/files"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,263 +21,263 @@ import (
// telemetryMiddleware implements files.Files interface instrumented with opentracing spans
type telemetryMiddleware struct {
files.Files
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base files.Files, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base files.Files, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Files: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// AbortUpload implements files.Files
-func (m telemetryMiddleware) AbortUpload(ctx context.Context, upload *files.MultipartUpload) (err error) {
+func (_d telemetryMiddleware) AbortUpload(ctx context.Context, upload *files.MultipartUpload) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Files"),
attribute.String("method", "AbortUpload"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.AbortUpload")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Files.AbortUpload")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"upload": upload}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Files.AbortUpload(ctx, upload)
+ return _d.Files.AbortUpload(ctx, upload)
}
// CompleteUpload implements files.Files
-func (m telemetryMiddleware) CompleteUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
+func (_d telemetryMiddleware) CompleteUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Files"),
attribute.String("method", "CompleteUpload"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.CompleteUpload")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Files.CompleteUpload")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"upload": upload}, map[string]interface{}{
"u": u,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Files.CompleteUpload(ctx, upload)
+ return _d.Files.CompleteUpload(ctx, upload)
}
// DeleteFile implements files.Files
-func (m telemetryMiddleware) DeleteFile(ctx context.Context, file *files.File) (err error) {
+func (_d telemetryMiddleware) DeleteFile(ctx context.Context, file *files.File) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Files"),
attribute.String("method", "DeleteFile"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.DeleteFile")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Files.DeleteFile")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"file": file}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Files.DeleteFile(ctx, file)
+ return _d.Files.DeleteFile(ctx, file)
}
// GetFile implements files.Files
-func (m telemetryMiddleware) GetFile(ctx context.Context, file *files.File) (f *files.File, err error) {
+func (_d telemetryMiddleware) GetFile(ctx context.Context, file *files.File) (f *files.File, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Files"),
attribute.String("method", "GetFile"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.GetFile")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Files.GetFile")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"file": file}, map[string]interface{}{
"f": f,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Files.GetFile(ctx, file)
+ return _d.Files.GetFile(ctx, file)
}
// MoveUpload implements files.Files
-func (m telemetryMiddleware) MoveUpload(ctx context.Context, upload *files.MultipartUpload) (file *files.File, err error) {
+func (_d telemetryMiddleware) MoveUpload(ctx context.Context, upload *files.MultipartUpload) (file *files.File, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Files"),
attribute.String("method", "MoveUpload"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.MoveUpload")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Files.MoveUpload")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"upload": upload}, map[string]interface{}{
"file": file,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Files.MoveUpload(ctx, upload)
+ return _d.Files.MoveUpload(ctx, upload)
}
// StartUpload implements files.Files
-func (m telemetryMiddleware) StartUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
+func (_d telemetryMiddleware) StartUpload(ctx context.Context, upload *files.MultipartUpload) (u *files.MultipartUpload, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Files"),
attribute.String("method", "StartUpload"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.StartUpload")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Files.StartUpload")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"upload": upload}, map[string]interface{}{
"u": u,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Files.StartUpload(ctx, upload)
+ return _d.Files.StartUpload(ctx, upload)
}
// Upload implements files.Files
-func (m telemetryMiddleware) Upload(ctx context.Context, file *files.File) (u *files.Upload, err error) {
+func (_d telemetryMiddleware) Upload(ctx context.Context, file *files.File) (u *files.Upload, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Files"),
attribute.String("method", "Upload"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.Upload")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Files.Upload")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"file": file}, map[string]interface{}{
"u": u,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Files.Upload(ctx, file)
+ return _d.Files.Upload(ctx, file)
}
diff --git a/pkg/invitations/middleware/telemetry_middleware.go b/pkg/invitations/middleware/telemetry_middleware.go
index 78bc0857..01f91983 100644
--- a/pkg/invitations/middleware/telemetry_middleware.go
+++ b/pkg/invitations/middleware/telemetry_middleware.go
@@ -12,7 +12,7 @@ import (
"git.perx.ru/perxis/perxis-go/pkg/invitations"
"git.perx.ru/perxis/perxis-go/pkg/options"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -22,149 +22,149 @@ import (
// telemetryMiddleware implements invitations.Invitations interface instrumented with opentracing spans
type telemetryMiddleware struct {
invitations.Invitations
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base invitations.Invitations, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base invitations.Invitations, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Invitations: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Accept implements invitations.Invitations
-func (m telemetryMiddleware) Accept(ctx context.Context, invitationId string, userId string) (err error) {
+func (_d telemetryMiddleware) Accept(ctx context.Context, invitationId string, userId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Invitations"),
attribute.String("method", "Accept"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Accept")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Invitations.Accept")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"invitationId": invitationId,
"userId": userId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Invitations.Accept(ctx, invitationId, userId)
+ return _d.Invitations.Accept(ctx, invitationId, userId)
}
// Create implements invitations.Invitations
-func (m telemetryMiddleware) Create(ctx context.Context, invitation *invitations.Invitation) (created *invitations.Invitation, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, invitation *invitations.Invitation) (created *invitations.Invitation, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Invitations"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Invitations.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"invitation": invitation}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Invitations.Create(ctx, invitation)
+ return _d.Invitations.Create(ctx, invitation)
}
// Delete implements invitations.Invitations
-func (m telemetryMiddleware) Delete(ctx context.Context, invitationId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, invitationId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Invitations"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Invitations.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"invitationId": invitationId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Invitations.Delete(ctx, invitationId)
+ return _d.Invitations.Delete(ctx, invitationId)
}
// Find implements invitations.Invitations
-func (m telemetryMiddleware) Find(ctx context.Context, filter *invitations.Filter, opts *options.FindOptions) (invitations []*invitations.Invitation, total int, err error) {
+func (_d telemetryMiddleware) Find(ctx context.Context, filter *invitations.Filter, opts *options.FindOptions) (invitations []*invitations.Invitation, total int, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Invitations"),
attribute.String("method", "Find"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Find")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Invitations.Find")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"filter": filter,
"opts": opts}, map[string]interface{}{
@@ -172,48 +172,48 @@ func (m telemetryMiddleware) Find(ctx context.Context, filter *invitations.Filte
"total": total,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Invitations.Find(ctx, filter, opts)
+ return _d.Invitations.Find(ctx, filter, opts)
}
// Get implements invitations.Invitations
-func (m telemetryMiddleware) Get(ctx context.Context, invitationId string) (invitation *invitations.Invitation, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, invitationId string) (invitation *invitations.Invitation, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Invitations"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Invitations.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"invitationId": invitationId}, map[string]interface{}{
"invitation": invitation,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Invitations.Get(ctx, invitationId)
+ return _d.Invitations.Get(ctx, invitationId)
}
diff --git a/pkg/items/middleware/telemetry_middleware.go b/pkg/items/middleware/telemetry_middleware.go
index a3a79499..71d79354 100644
--- a/pkg/items/middleware/telemetry_middleware.go
+++ b/pkg/items/middleware/telemetry_middleware.go
@@ -12,7 +12,7 @@ import (
"git.perx.ru/perxis/perxis-go/pkg/items"
"git.perx.ru/perxis/perxis-go/pkg/schema"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -22,48 +22,48 @@ import (
// telemetryMiddleware implements items.Items interface instrumented with opentracing spans
type telemetryMiddleware struct {
items.Items
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base items.Items, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base items.Items, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Items: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Aggregate implements items.Items
-func (m telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregateOptions) (result map[string]interface{}, err error) {
+func (_d telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregateOptions) (result map[string]interface{}, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Aggregate"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Aggregate")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Aggregate")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -73,35 +73,35 @@ func (m telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envI
"result": result,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
+ return _d.Items.Aggregate(ctx, spaceId, envId, collectionId, filter, options...)
}
// AggregatePublished implements items.Items
-func (m telemetryMiddleware) AggregatePublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
+func (_d telemetryMiddleware) AggregatePublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.AggregatePublishedOptions) (result map[string]interface{}, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "AggregatePublished"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.AggregatePublished")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.AggregatePublished")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -111,138 +111,138 @@ func (m telemetryMiddleware) AggregatePublished(ctx context.Context, spaceId str
"result": result,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.AggregatePublished(ctx, spaceId, envId, collectionId, filter, options...)
+ return _d.Items.AggregatePublished(ctx, spaceId, envId, collectionId, filter, options...)
}
// Archive implements items.Items
-func (m telemetryMiddleware) Archive(ctx context.Context, item *items.Item, options ...*items.ArchiveOptions) (err error) {
+func (_d telemetryMiddleware) Archive(ctx context.Context, item *items.Item, options ...*items.ArchiveOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Archive"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Archive")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Archive")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Archive(ctx, item, options...)
+ return _d.Items.Archive(ctx, item, options...)
}
// Create implements items.Items
-func (m telemetryMiddleware) Create(ctx context.Context, item *items.Item, opts ...*items.CreateOptions) (created *items.Item, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, item *items.Item, opts ...*items.CreateOptions) (created *items.Item, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"opts": opts}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Create(ctx, item, opts...)
+ return _d.Items.Create(ctx, item, opts...)
}
// Delete implements items.Items
-func (m telemetryMiddleware) Delete(ctx context.Context, item *items.Item, options ...*items.DeleteOptions) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, item *items.Item, options ...*items.DeleteOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Delete(ctx, item, options...)
+ return _d.Items.Delete(ctx, item, options...)
}
// Find implements items.Items
-func (m telemetryMiddleware) Find(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindOptions) (items []*items.Item, total int, err error) {
+func (_d telemetryMiddleware) Find(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindOptions) (items []*items.Item, total int, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Find"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Find")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Find")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -253,35 +253,35 @@ func (m telemetryMiddleware) Find(ctx context.Context, spaceId string, envId str
"total": total,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Find(ctx, spaceId, envId, collectionId, filter, options...)
+ return _d.Items.Find(ctx, spaceId, envId, collectionId, filter, options...)
}
// FindArchived implements items.Items
-func (m telemetryMiddleware) FindArchived(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindArchivedOptions) (items []*items.Item, total int, err error) {
+func (_d telemetryMiddleware) FindArchived(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindArchivedOptions) (items []*items.Item, total int, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "FindArchived"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.FindArchived")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.FindArchived")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -292,35 +292,35 @@ func (m telemetryMiddleware) FindArchived(ctx context.Context, spaceId string, e
"total": total,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.FindArchived(ctx, spaceId, envId, collectionId, filter, options...)
+ return _d.Items.FindArchived(ctx, spaceId, envId, collectionId, filter, options...)
}
// FindPublished implements items.Items
-func (m telemetryMiddleware) FindPublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindPublishedOptions) (items []*items.Item, total int, err error) {
+func (_d telemetryMiddleware) FindPublished(ctx context.Context, spaceId string, envId string, collectionId string, filter *items.Filter, options ...*items.FindPublishedOptions) (items []*items.Item, total int, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "FindPublished"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.FindPublished")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.FindPublished")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -331,35 +331,35 @@ func (m telemetryMiddleware) FindPublished(ctx context.Context, spaceId string,
"total": total,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.FindPublished(ctx, spaceId, envId, collectionId, filter, options...)
+ return _d.Items.FindPublished(ctx, spaceId, envId, collectionId, filter, options...)
}
// Get implements items.Items
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetOptions) (item *items.Item, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetOptions) (item *items.Item, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -369,35 +369,35 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId stri
"item": item,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Get(ctx, spaceId, envId, collectionId, itemId, options...)
+ return _d.Items.Get(ctx, spaceId, envId, collectionId, itemId, options...)
}
// GetPublished implements items.Items
-func (m telemetryMiddleware) GetPublished(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetPublishedOptions) (item *items.Item, err error) {
+func (_d telemetryMiddleware) GetPublished(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.GetPublishedOptions) (item *items.Item, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "GetPublished"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.GetPublished")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.GetPublished")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -407,35 +407,35 @@ func (m telemetryMiddleware) GetPublished(ctx context.Context, spaceId string, e
"item": item,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.GetPublished(ctx, spaceId, envId, collectionId, itemId, options...)
+ return _d.Items.GetPublished(ctx, spaceId, envId, collectionId, itemId, options...)
}
// GetRevision implements items.Items
-func (m telemetryMiddleware) GetRevision(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, revisionId string, options ...*items.GetRevisionOptions) (item *items.Item, err error) {
+func (_d telemetryMiddleware) GetRevision(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, revisionId string, options ...*items.GetRevisionOptions) (item *items.Item, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "GetRevision"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.GetRevision")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.GetRevision")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -446,35 +446,35 @@ func (m telemetryMiddleware) GetRevision(ctx context.Context, spaceId string, en
"item": item,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.GetRevision(ctx, spaceId, envId, collectionId, itemId, revisionId, options...)
+ return _d.Items.GetRevision(ctx, spaceId, envId, collectionId, itemId, revisionId, options...)
}
// Introspect implements items.Items
-func (m telemetryMiddleware) Introspect(ctx context.Context, item *items.Item, opts ...*items.IntrospectOptions) (itm *items.Item, sch *schema.Schema, err error) {
+func (_d telemetryMiddleware) Introspect(ctx context.Context, item *items.Item, opts ...*items.IntrospectOptions) (itm *items.Item, sch *schema.Schema, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Introspect"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Introspect")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Introspect")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"opts": opts}, map[string]interface{}{
@@ -482,35 +482,35 @@ func (m telemetryMiddleware) Introspect(ctx context.Context, item *items.Item, o
"sch": sch,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Introspect(ctx, item, opts...)
+ return _d.Items.Introspect(ctx, item, opts...)
}
// ListRevisions implements items.Items
-func (m telemetryMiddleware) ListRevisions(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.ListRevisionsOptions) (items []*items.Item, err error) {
+func (_d telemetryMiddleware) ListRevisions(ctx context.Context, spaceId string, envId string, collectionId string, itemId string, options ...*items.ListRevisionsOptions) (items []*items.Item, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "ListRevisions"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.ListRevisions")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.ListRevisions")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -520,184 +520,184 @@ func (m telemetryMiddleware) ListRevisions(ctx context.Context, spaceId string,
"items": items,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.ListRevisions(ctx, spaceId, envId, collectionId, itemId, options...)
+ return _d.Items.ListRevisions(ctx, spaceId, envId, collectionId, itemId, options...)
}
// Publish implements items.Items
-func (m telemetryMiddleware) Publish(ctx context.Context, item *items.Item, options ...*items.PublishOptions) (err error) {
+func (_d telemetryMiddleware) Publish(ctx context.Context, item *items.Item, options ...*items.PublishOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Publish"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Publish")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Publish")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Publish(ctx, item, options...)
+ return _d.Items.Publish(ctx, item, options...)
}
// Unarchive implements items.Items
-func (m telemetryMiddleware) Unarchive(ctx context.Context, item *items.Item, options ...*items.UnarchiveOptions) (err error) {
+func (_d telemetryMiddleware) Unarchive(ctx context.Context, item *items.Item, options ...*items.UnarchiveOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Unarchive"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Unarchive")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Unarchive")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Unarchive(ctx, item, options...)
+ return _d.Items.Unarchive(ctx, item, options...)
}
// Undelete implements items.Items
-func (m telemetryMiddleware) Undelete(ctx context.Context, item *items.Item, options ...*items.UndeleteOptions) (err error) {
+func (_d telemetryMiddleware) Undelete(ctx context.Context, item *items.Item, options ...*items.UndeleteOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Undelete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Undelete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Undelete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Undelete(ctx, item, options...)
+ return _d.Items.Undelete(ctx, item, options...)
}
// Unpublish implements items.Items
-func (m telemetryMiddleware) Unpublish(ctx context.Context, item *items.Item, options ...*items.UnpublishOptions) (err error) {
+func (_d telemetryMiddleware) Unpublish(ctx context.Context, item *items.Item, options ...*items.UnpublishOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Unpublish"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Unpublish")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Unpublish")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Unpublish(ctx, item, options...)
+ return _d.Items.Unpublish(ctx, item, options...)
}
// Update implements items.Items
-func (m telemetryMiddleware) Update(ctx context.Context, item *items.Item, options ...*items.UpdateOptions) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, item *items.Item, options ...*items.UpdateOptions) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Items"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Items.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"item": item,
"options": options}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Items.Update(ctx, item, options...)
+ return _d.Items.Update(ctx, item, options...)
}
diff --git a/pkg/locales/middleware/telemetry_middleware.go b/pkg/locales/middleware/telemetry_middleware.go
index ae10d4aa..90565366 100644
--- a/pkg/locales/middleware/telemetry_middleware.go
+++ b/pkg/locales/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/locales"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,129 +21,129 @@ import (
// telemetryMiddleware implements locales.Locales interface instrumented with opentracing spans
type telemetryMiddleware struct {
locales.Locales
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base locales.Locales, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base locales.Locales, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Locales: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Create implements locales.Locales
-func (m telemetryMiddleware) Create(ctx context.Context, locale *locales.Locale) (created *locales.Locale, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, locale *locales.Locale) (created *locales.Locale, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Locales"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Locales.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Locales.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"locale": locale}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Locales.Create(ctx, locale)
+ return _d.Locales.Create(ctx, locale)
}
// Delete implements locales.Locales
-func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, localeId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, spaceId string, localeId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Locales"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Locales.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Locales.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"localeId": localeId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Locales.Delete(ctx, spaceId, localeId)
+ return _d.Locales.Delete(ctx, spaceId, localeId)
}
// List implements locales.Locales
-func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (locales []*locales.Locale, err error) {
+func (_d telemetryMiddleware) List(ctx context.Context, spaceId string) (locales []*locales.Locale, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Locales"),
attribute.String("method", "List"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Locales.List")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Locales.List")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"locales": locales,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Locales.List(ctx, spaceId)
+ return _d.Locales.List(ctx, spaceId)
}
diff --git a/pkg/members/middleware/telemetry_middleware.go b/pkg/members/middleware/telemetry_middleware.go
index d8d53d43..493d9fe2 100644
--- a/pkg/members/middleware/telemetry_middleware.go
+++ b/pkg/members/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/members"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,232 +21,232 @@ import (
// telemetryMiddleware implements members.Members interface instrumented with opentracing spans
type telemetryMiddleware struct {
members.Members
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base members.Members, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base members.Members, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Members: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Get implements members.Members
-func (m telemetryMiddleware) Get(ctx context.Context, orgId string, userId string) (role members.Role, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, orgId string, userId string) (role members.Role, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Members"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Members.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId,
"userId": userId}, map[string]interface{}{
"role": role,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Members.Get(ctx, orgId, userId)
+ return _d.Members.Get(ctx, orgId, userId)
}
// ListMembers implements members.Members
-func (m telemetryMiddleware) ListMembers(ctx context.Context, orgId string) (members []*members.Member, err error) {
+func (_d telemetryMiddleware) ListMembers(ctx context.Context, orgId string) (members []*members.Member, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Members"),
attribute.String("method", "ListMembers"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.ListMembers")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Members.ListMembers")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId}, map[string]interface{}{
"members": members,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Members.ListMembers(ctx, orgId)
+ return _d.Members.ListMembers(ctx, orgId)
}
// ListOrganizations implements members.Members
-func (m telemetryMiddleware) ListOrganizations(ctx context.Context, userId string) (organizations []*members.Member, err error) {
+func (_d telemetryMiddleware) ListOrganizations(ctx context.Context, userId string) (organizations []*members.Member, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Members"),
attribute.String("method", "ListOrganizations"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.ListOrganizations")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Members.ListOrganizations")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"userId": userId}, map[string]interface{}{
"organizations": organizations,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Members.ListOrganizations(ctx, userId)
+ return _d.Members.ListOrganizations(ctx, userId)
}
// Remove implements members.Members
-func (m telemetryMiddleware) Remove(ctx context.Context, orgId string, userId string) (err error) {
+func (_d telemetryMiddleware) Remove(ctx context.Context, orgId string, userId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Members"),
attribute.String("method", "Remove"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.Remove")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Members.Remove")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId,
"userId": userId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Members.Remove(ctx, orgId, userId)
+ return _d.Members.Remove(ctx, orgId, userId)
}
// RemoveAll implements members.Members
-func (m telemetryMiddleware) RemoveAll(ctx context.Context, orgId string) (err error) {
+func (_d telemetryMiddleware) RemoveAll(ctx context.Context, orgId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Members"),
attribute.String("method", "RemoveAll"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.RemoveAll")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Members.RemoveAll")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Members.RemoveAll(ctx, orgId)
+ return _d.Members.RemoveAll(ctx, orgId)
}
// Set implements members.Members
-func (m telemetryMiddleware) Set(ctx context.Context, orgId string, userId string, role members.Role) (err error) {
+func (_d telemetryMiddleware) Set(ctx context.Context, orgId string, userId string, role members.Role) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Members"),
attribute.String("method", "Set"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.Set")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Members.Set")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId,
"userId": userId,
"role": role}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Members.Set(ctx, orgId, userId, role)
+ return _d.Members.Set(ctx, orgId, userId, role)
}
diff --git a/pkg/organizations/middleware/telemetry_middleware.go b/pkg/organizations/middleware/telemetry_middleware.go
index ac2e9d35..9b83541a 100644
--- a/pkg/organizations/middleware/telemetry_middleware.go
+++ b/pkg/organizations/middleware/telemetry_middleware.go
@@ -12,7 +12,7 @@ import (
"git.perx.ru/perxis/perxis-go/pkg/options"
"git.perx.ru/perxis/perxis-go/pkg/organizations"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -22,115 +22,115 @@ import (
// telemetryMiddleware implements organizations.Organizations interface instrumented with opentracing spans
type telemetryMiddleware struct {
organizations.Organizations
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base organizations.Organizations, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base organizations.Organizations, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Organizations: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Create implements organizations.Organizations
-func (m telemetryMiddleware) Create(ctx context.Context, org *organizations.Organization) (created *organizations.Organization, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, org *organizations.Organization) (created *organizations.Organization, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Organizations"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Organizations.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"org": org}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Organizations.Create(ctx, org)
+ return _d.Organizations.Create(ctx, org)
}
// Delete implements organizations.Organizations
-func (m telemetryMiddleware) Delete(ctx context.Context, orgId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, orgId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Organizations"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Organizations.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Organizations.Delete(ctx, orgId)
+ return _d.Organizations.Delete(ctx, orgId)
}
// Find implements organizations.Organizations
-func (m telemetryMiddleware) Find(ctx context.Context, filter *organizations.Filter, opts *options.FindOptions) (orgs []*organizations.Organization, total int, err error) {
+func (_d telemetryMiddleware) Find(ctx context.Context, filter *organizations.Filter, opts *options.FindOptions) (orgs []*organizations.Organization, total int, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Organizations"),
attribute.String("method", "Find"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Find")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Organizations.Find")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"filter": filter,
"opts": opts}, map[string]interface{}{
@@ -138,81 +138,81 @@ func (m telemetryMiddleware) Find(ctx context.Context, filter *organizations.Fil
"total": total,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Organizations.Find(ctx, filter, opts)
+ return _d.Organizations.Find(ctx, filter, opts)
}
// Get implements organizations.Organizations
-func (m telemetryMiddleware) Get(ctx context.Context, orgId string) (org *organizations.Organization, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, orgId string) (org *organizations.Organization, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Organizations"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Organizations.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId}, map[string]interface{}{
"org": org,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Organizations.Get(ctx, orgId)
+ return _d.Organizations.Get(ctx, orgId)
}
// Update implements organizations.Organizations
-func (m telemetryMiddleware) Update(ctx context.Context, org *organizations.Organization) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, org *organizations.Organization) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Organizations"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Organizations.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"org": org}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Organizations.Update(ctx, org)
+ return _d.Organizations.Update(ctx, org)
}
diff --git a/pkg/references/middleware/telemetry_middleware.go b/pkg/references/middleware/telemetry_middleware.go
index 58f24355..de4533ba 100644
--- a/pkg/references/middleware/telemetry_middleware.go
+++ b/pkg/references/middleware/telemetry_middleware.go
@@ -12,7 +12,7 @@ import (
"git.perx.ru/perxis/perxis-go/pkg/items"
"git.perx.ru/perxis/perxis-go/pkg/references"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -22,48 +22,48 @@ import (
// telemetryMiddleware implements references.References interface instrumented with opentracing spans
type telemetryMiddleware struct {
references.References
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base references.References, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base references.References, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
References: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Get implements references.References
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string, references []*references.Reference) (items []*items.Item, notfound []*references.Reference, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string, envId string, references []*references.Reference) (items []*items.Item, notfound []*references.Reference, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "References"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "References.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "References.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -72,35 +72,35 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId stri
"notfound": notfound,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.References.Get(ctx, spaceId, envId, references)
+ return _d.References.Get(ctx, spaceId, envId, references)
}
// Publish implements references.References
-func (m telemetryMiddleware) Publish(ctx context.Context, spaceId string, envId string, references []*references.Reference, recursive bool, force bool) (published []*references.Reference, notfound []*references.Reference, unpublished []*references.Reference, err error) {
+func (_d telemetryMiddleware) Publish(ctx context.Context, spaceId string, envId string, references []*references.Reference, recursive bool, force bool) (published []*references.Reference, notfound []*references.Reference, unpublished []*references.Reference, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "References"),
attribute.String("method", "Publish"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "References.Publish")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "References.Publish")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"envId": envId,
@@ -112,14 +112,14 @@ func (m telemetryMiddleware) Publish(ctx context.Context, spaceId string, envId
"unpublished": unpublished,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.References.Publish(ctx, spaceId, envId, references, recursive, force)
+ return _d.References.Publish(ctx, spaceId, envId, references, recursive, force)
}
diff --git a/pkg/roles/middleware/telemetry_middleware.go b/pkg/roles/middleware/telemetry_middleware.go
index a44b876e..72666a14 100644
--- a/pkg/roles/middleware/telemetry_middleware.go
+++ b/pkg/roles/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/roles"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,197 +21,197 @@ import (
// telemetryMiddleware implements roles.Roles interface instrumented with opentracing spans
type telemetryMiddleware struct {
roles.Roles
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base roles.Roles, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base roles.Roles, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Roles: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Create implements roles.Roles
-func (m telemetryMiddleware) Create(ctx context.Context, role *roles.Role) (created *roles.Role, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, role *roles.Role) (created *roles.Role, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Roles"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Roles.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"role": role}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Roles.Create(ctx, role)
+ return _d.Roles.Create(ctx, role)
}
// Delete implements roles.Roles
-func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, roleId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, spaceId string, roleId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Roles"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Roles.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"roleId": roleId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Roles.Delete(ctx, spaceId, roleId)
+ return _d.Roles.Delete(ctx, spaceId, roleId)
}
// Get implements roles.Roles
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, roleId string) (role *roles.Role, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string, roleId string) (role *roles.Role, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Roles"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Roles.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"roleId": roleId}, map[string]interface{}{
"role": role,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Roles.Get(ctx, spaceId, roleId)
+ return _d.Roles.Get(ctx, spaceId, roleId)
}
// List implements roles.Roles
-func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (roles []*roles.Role, err error) {
+func (_d telemetryMiddleware) List(ctx context.Context, spaceId string) (roles []*roles.Role, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Roles"),
attribute.String("method", "List"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.List")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Roles.List")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"roles": roles,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Roles.List(ctx, spaceId)
+ return _d.Roles.List(ctx, spaceId)
}
// Update implements roles.Roles
-func (m telemetryMiddleware) Update(ctx context.Context, role *roles.Role) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, role *roles.Role) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Roles"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Roles.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"role": role}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Roles.Update(ctx, role)
+ return _d.Roles.Update(ctx, role)
}
diff --git a/pkg/spaces/middleware/telemetry_middleware.go b/pkg/spaces/middleware/telemetry_middleware.go
index a6df52b3..42caaf89 100644
--- a/pkg/spaces/middleware/telemetry_middleware.go
+++ b/pkg/spaces/middleware/telemetry_middleware.go
@@ -11,7 +11,7 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/spaces"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -21,364 +21,364 @@ import (
// telemetryMiddleware implements spaces.Spaces interface instrumented with opentracing spans
type telemetryMiddleware struct {
spaces.Spaces
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base spaces.Spaces, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base spaces.Spaces, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Spaces: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// AbortTransfer implements spaces.Spaces
-func (m telemetryMiddleware) AbortTransfer(ctx context.Context, spaceID string) (err error) {
+func (_d telemetryMiddleware) AbortTransfer(ctx context.Context, spaceID string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "AbortTransfer"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.AbortTransfer")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.AbortTransfer")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceID": spaceID}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.AbortTransfer(ctx, spaceID)
+ return _d.Spaces.AbortTransfer(ctx, spaceID)
}
// Create implements spaces.Spaces
-func (m telemetryMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, space *spaces.Space) (created *spaces.Space, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"space": space}, map[string]interface{}{
"created": created,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.Create(ctx, space)
+ return _d.Spaces.Create(ctx, space)
}
// Delete implements spaces.Spaces
-func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, spaceId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.Delete(ctx, spaceId)
+ return _d.Spaces.Delete(ctx, spaceId)
}
// Get implements spaces.Spaces
-func (m telemetryMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, spaceId string) (space *spaces.Space, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId}, map[string]interface{}{
"space": space,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.Get(ctx, spaceId)
+ return _d.Spaces.Get(ctx, spaceId)
}
// List implements spaces.Spaces
-func (m telemetryMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
+func (_d telemetryMiddleware) List(ctx context.Context, orgId string) (spaces []*spaces.Space, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "List"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.List")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.List")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgId": orgId}, map[string]interface{}{
"spaces": spaces,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.List(ctx, orgId)
+ return _d.Spaces.List(ctx, orgId)
}
// ListTransfers implements spaces.Spaces
-func (m telemetryMiddleware) ListTransfers(ctx context.Context, orgID string) (spaces []*spaces.Space, err error) {
+func (_d telemetryMiddleware) ListTransfers(ctx context.Context, orgID string) (spaces []*spaces.Space, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "ListTransfers"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.ListTransfers")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.ListTransfers")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"orgID": orgID}, map[string]interface{}{
"spaces": spaces,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.ListTransfers(ctx, orgID)
+ return _d.Spaces.ListTransfers(ctx, orgID)
}
// Move implements spaces.Spaces
-func (m telemetryMiddleware) Move(ctx context.Context, spaceID string, orgID string) (err error) {
+func (_d telemetryMiddleware) Move(ctx context.Context, spaceID string, orgID string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "Move"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Move")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.Move")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceID": spaceID,
"orgID": orgID}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.Move(ctx, spaceID, orgID)
+ return _d.Spaces.Move(ctx, spaceID, orgID)
}
// Transfer implements spaces.Spaces
-func (m telemetryMiddleware) Transfer(ctx context.Context, spaceID string, transferToOrg string) (err error) {
+func (_d telemetryMiddleware) Transfer(ctx context.Context, spaceID string, transferToOrg string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "Transfer"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Transfer")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.Transfer")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceID": spaceID,
"transferToOrg": transferToOrg}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.Transfer(ctx, spaceID, transferToOrg)
+ return _d.Spaces.Transfer(ctx, spaceID, transferToOrg)
}
// Update implements spaces.Spaces
-func (m telemetryMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, space *spaces.Space) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"space": space}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.Update(ctx, space)
+ return _d.Spaces.Update(ctx, space)
}
// UpdateConfig implements spaces.Spaces
-func (m telemetryMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
+func (_d telemetryMiddleware) UpdateConfig(ctx context.Context, spaceId string, config *spaces.Config) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Spaces"),
attribute.String("method", "UpdateConfig"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.UpdateConfig")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Spaces.UpdateConfig")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"spaceId": spaceId,
"config": config}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Spaces.UpdateConfig(ctx, spaceId, config)
+ return _d.Spaces.UpdateConfig(ctx, spaceId, config)
}
diff --git a/telemetry/metrics/cache.go b/pkg/telemetry/metrics/cache.go
similarity index 100%
rename from telemetry/metrics/cache.go
rename to pkg/telemetry/metrics/cache.go
diff --git a/telemetry/metrics/request.go b/pkg/telemetry/metrics/request.go
similarity index 100%
rename from telemetry/metrics/request.go
rename to pkg/telemetry/metrics/request.go
diff --git a/pkg/users/middleware/telemetry_middleware.go b/pkg/users/middleware/telemetry_middleware.go
index 14dbc441..730fab46 100644
--- a/pkg/users/middleware/telemetry_middleware.go
+++ b/pkg/users/middleware/telemetry_middleware.go
@@ -11,8 +11,8 @@ import (
"time"
"git.perx.ru/perxis/perxis-go/pkg/options"
+ "git.perx.ru/perxis/perxis-go/pkg/telemetry/metrics"
"git.perx.ru/perxis/perxis-go/pkg/users"
- "git.perx.ru/perxis/perxis-go/telemetry/metrics"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/attribute"
otelmetric "go.opentelemetry.io/otel/metric"
@@ -22,115 +22,115 @@ import (
// telemetryMiddleware implements users.Users interface instrumented with opentracing spans
type telemetryMiddleware struct {
users.Users
- scope string
+ _instance string
requestMetrics *metrics.RequestMetrics
- spanDecorator func(span trace.Span, params, results map[string]interface{})
+ _spanDecorator func(span trace.Span, params, results map[string]interface{})
}
// TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base users.Users, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base users.Users, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
requestMetrics, err := metrics.GetRequestMetrics()
if err != nil {
panic(err)
}
- m := telemetryMiddleware{
+ d := telemetryMiddleware{
Users: base,
- scope: scope,
+ _instance: instance,
requestMetrics: requestMetrics,
}
if len(spanDecorator) > 0 && spanDecorator[0] != nil {
- m.spanDecorator = spanDecorator[0]
+ d._spanDecorator = spanDecorator[0]
}
- return m
+ return d
}
// Create implements users.Users
-func (m telemetryMiddleware) Create(ctx context.Context, create *users.User) (user *users.User, err error) {
+func (_d telemetryMiddleware) Create(ctx context.Context, create *users.User) (user *users.User, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Users"),
attribute.String("method", "Create"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Create")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Users.Create")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"create": create}, map[string]interface{}{
"user": user,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Users.Create(ctx, create)
+ return _d.Users.Create(ctx, create)
}
// Delete implements users.Users
-func (m telemetryMiddleware) Delete(ctx context.Context, userId string) (err error) {
+func (_d telemetryMiddleware) Delete(ctx context.Context, userId string) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Users"),
attribute.String("method", "Delete"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Delete")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Users.Delete")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"userId": userId}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Users.Delete(ctx, userId)
+ return _d.Users.Delete(ctx, userId)
}
// Find implements users.Users
-func (m telemetryMiddleware) Find(ctx context.Context, filter *users.Filter, options *options.FindOptions) (users []*users.User, total int, err error) {
+func (_d telemetryMiddleware) Find(ctx context.Context, filter *users.Filter, options *options.FindOptions) (users []*users.User, total int, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Users"),
attribute.String("method", "Find"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Find")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Users.Find")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"filter": filter,
"options": options}, map[string]interface{}{
@@ -138,115 +138,115 @@ func (m telemetryMiddleware) Find(ctx context.Context, filter *users.Filter, opt
"total": total,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Users.Find(ctx, filter, options)
+ return _d.Users.Find(ctx, filter, options)
}
// Get implements users.Users
-func (m telemetryMiddleware) Get(ctx context.Context, userId string) (user *users.User, err error) {
+func (_d telemetryMiddleware) Get(ctx context.Context, userId string) (user *users.User, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Users"),
attribute.String("method", "Get"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Get")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Users.Get")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"userId": userId}, map[string]interface{}{
"user": user,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Users.Get(ctx, userId)
+ return _d.Users.Get(ctx, userId)
}
// GetByIdentity implements users.Users
-func (m telemetryMiddleware) GetByIdentity(ctx context.Context, identity string) (user *users.User, err error) {
+func (_d telemetryMiddleware) GetByIdentity(ctx context.Context, identity string) (user *users.User, err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Users"),
attribute.String("method", "GetByIdentity"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.GetByIdentity")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Users.GetByIdentity")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"identity": identity}, map[string]interface{}{
"user": user,
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Users.GetByIdentity(ctx, identity)
+ return _d.Users.GetByIdentity(ctx, identity)
}
// Update implements users.Users
-func (m telemetryMiddleware) Update(ctx context.Context, update *users.User) (err error) {
+func (_d telemetryMiddleware) Update(ctx context.Context, update *users.User) (err error) {
attributes := otelmetric.WithAttributeSet(attribute.NewSet(
attribute.String("service", "Users"),
attribute.String("method", "Update"),
))
- m.requestMetrics.Total.Add(ctx, 1, attributes)
+ _d.requestMetrics.Total.Add(ctx, 1, attributes)
start := time.Now()
- ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Update")
+ ctx, _span := otel.Tracer(_d._instance).Start(ctx, "Users.Update")
defer func() {
- m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
+ _d.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
- if m.spanDecorator != nil {
- m.spanDecorator(span, map[string]interface{}{
+ if _d._spanDecorator != nil {
+ _d._spanDecorator(_span, map[string]interface{}{
"ctx": ctx,
"update": update}, map[string]interface{}{
"err": err})
} else if err != nil {
- m.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
+ _d.requestMetrics.FailedTotal.Add(ctx, 1, attributes)
- span.RecordError(err)
- span.SetAttributes(attribute.String("event", "error"))
- span.SetAttributes(attribute.String("message", err.Error()))
+ _span.RecordError(err)
+ _span.SetAttributes(attribute.String("event", "error"))
+ _span.SetAttributes(attribute.String("message", err.Error()))
}
- span.End()
+ _span.End()
}()
- return m.Users.Update(ctx, update)
+ return _d.Users.Update(ctx, update)
}
--
GitLab