diff --git a/assets/templates/middleware/telemetry b/assets/templates/middleware/telemetry
index 81a167e3211e3fa5e32dc16e03421dfe1ebc8a52..57be255c062bbee7403d8bb9fadf8376a04a620e 100644
--- a/assets/templates/middleware/telemetry
+++ b/assets/templates/middleware/telemetry
@@ -15,13 +15,13 @@ import (
 // {{$decorator}} implements {{.Interface.Type}} interface instrumented with opentracing spans
 type {{$decorator}} struct {
   {{.Interface.Type}}
-  instance string
+  scope string
   requestMetrics *metrics.RequestMetrics
   spanDecorator func(span trace.Span, params, results map[string]interface{})
 }
 
 // {{$funcName}} returns {{$decorator}}
-func {{$funcName}} (base {{.Interface.Type}}, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) {{$decorator}} {
+func {{$funcName}} (base {{.Interface.Type}}, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) {{$decorator}} {
   requestMetrics, err := metrics.GetRequestMetrics()
   if err != nil {
     panic(err)
@@ -29,7 +29,7 @@ func {{$funcName}} (base {{.Interface.Type}}, instance string, spanDecorator ...
 
   m := {{$decorator}} {
     {{.Interface.Name}}: base,
-    instance: instance,
+    scope: scope,
     requestMetrics: requestMetrics,
   }
 
@@ -52,7 +52,7 @@ func (m {{$decorator}}) {{$method.Declaration}} {
   m.requestMetrics.Total.Add(ctx, 1, attributes)
 
   start := time.Now()
-  ctx, span := otel.Tracer(m.instance).Start(ctx, "{{$.Interface.Name}}.{{$method.Name}}")
+  ctx, span := otel.Tracer(m.scope).Start(ctx, "{{$.Interface.Name}}.{{$method.Name}}")
 
   defer func() {
     m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/images/middleware/telemetry_middleware.go b/images/middleware/telemetry_middleware.go
index 22159735709510a515de1e31ea451f62fbd7fccb..1a450dc8938481427d995d56f254ed3d78475a34 100644
--- a/images/middleware/telemetry_middleware.go
+++ b/images/middleware/telemetry_middleware.go
@@ -22,13 +22,13 @@ import (
 // telemetryMiddleware implements images.Images interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	images.Images
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base images.Images, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base images.Images, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -36,7 +36,7 @@ func TelemetryMiddleware(base images.Images, instance string, spanDecorator ...f
 
 	m := telemetryMiddleware{
 		Images:         base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -57,7 +57,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, source *files.File, opts *
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Images.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Images.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/clients/middleware/telemetry_middleware.go b/pkg/clients/middleware/telemetry_middleware.go
index 64c523942de2bbd4d87825d7ec1b56afd89b5dfe..d5b3e54ea60ec478b849231f55d0df9a952b140c 100644
--- a/pkg/clients/middleware/telemetry_middleware.go
+++ b/pkg/clients/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements clients.Clients interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	clients.Clients
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base clients.Clients, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base clients.Clients, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base clients.Clients, instance string, spanDecorator ..
 
 	m := telemetryMiddleware{
 		Clients:        base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, client *clients.Client)
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Clients.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -90,7 +90,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, id stri
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Clients.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -124,7 +124,7 @@ func (m telemetryMiddleware) Enable(ctx context.Context, spaceId string, id stri
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Clients.Enable")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Enable")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -159,7 +159,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, id string)
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Clients.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -194,7 +194,7 @@ func (m telemetryMiddleware) GetBy(ctx context.Context, spaceId string, params *
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Clients.GetBy")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.GetBy")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -229,7 +229,7 @@ func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (clients
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Clients.List")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.List")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -263,7 +263,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, client *clients.Client)
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Clients.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Clients.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/collaborators/middleware/telemetry_middleware.go b/pkg/collaborators/middleware/telemetry_middleware.go
index ed0546bb5fad5e2ea0ecbec59188547adfb104ec..457f09956e348cf81adbe600ab75b0edde6cac60 100644
--- a/pkg/collaborators/middleware/telemetry_middleware.go
+++ b/pkg/collaborators/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements collaborators.Collaborators interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	collaborators.Collaborators
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base collaborators.Collaborators, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base collaborators.Collaborators, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base collaborators.Collaborators, instance string, span
 
 	m := telemetryMiddleware{
 		Collaborators:  base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, subject st
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collaborators.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -91,7 +91,7 @@ func (m telemetryMiddleware) ListCollaborators(ctx context.Context, spaceId stri
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collaborators.ListCollaborators")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.ListCollaborators")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -125,7 +125,7 @@ func (m telemetryMiddleware) ListSpaces(ctx context.Context, subject string) (sp
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collaborators.ListSpaces")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.ListSpaces")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -159,7 +159,7 @@ func (m telemetryMiddleware) Remove(ctx context.Context, spaceId string, subject
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collaborators.Remove")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.Remove")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -193,7 +193,7 @@ func (m telemetryMiddleware) Set(ctx context.Context, spaceId string, subject st
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collaborators.Set")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collaborators.Set")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/collections/middleware/telemetry_middleware.go b/pkg/collections/middleware/telemetry_middleware.go
index 68e7ea6a49a332064208e312d7f06aed401f0248..cfaa9355b2d3a3cbbecc2947dcedd5818d4926a4 100644
--- a/pkg/collections/middleware/telemetry_middleware.go
+++ b/pkg/collections/middleware/telemetry_middleware.go
@@ -22,13 +22,13 @@ import (
 // telemetryMiddleware implements collections.Collections interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	collections.Collections
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base collections.Collections, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base collections.Collections, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -36,7 +36,7 @@ func TelemetryMiddleware(base collections.Collections, instance string, spanDeco
 
 	m := telemetryMiddleware{
 		Collections:    base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -57,7 +57,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, collection *collections
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collections.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -91,7 +91,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, envId s
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collections.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -126,7 +126,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId stri
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collections.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -163,7 +163,7 @@ func (m telemetryMiddleware) List(ctx context.Context, spaceId string, envId str
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collections.List")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.List")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -199,7 +199,7 @@ func (m telemetryMiddleware) SetSchema(ctx context.Context, spaceId string, envI
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collections.SetSchema")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.SetSchema")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -235,7 +235,7 @@ func (m telemetryMiddleware) SetState(ctx context.Context, spaceId string, envId
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collections.SetState")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.SetState")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -271,7 +271,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, coll *collections.Colle
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Collections.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Collections.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/delivery/middleware/telemetry_middleware.go b/pkg/delivery/middleware/telemetry_middleware.go
index 2f1cfcc4b03d16585d042d5577b5815d72c04b68..cd7f52114d72604faede67b08122fa9c59fb4909 100644
--- a/pkg/delivery/middleware/telemetry_middleware.go
+++ b/pkg/delivery/middleware/telemetry_middleware.go
@@ -25,13 +25,13 @@ import (
 // telemetryMiddleware implements delivery.Delivery interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	delivery.Delivery
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base delivery.Delivery, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base delivery.Delivery, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -39,7 +39,7 @@ func TelemetryMiddleware(base delivery.Delivery, instance string, spanDecorator
 
 	m := telemetryMiddleware{
 		Delivery:       base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -60,7 +60,7 @@ func (m telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envI
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.Aggregate")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.Aggregate")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -98,7 +98,7 @@ func (m telemetryMiddleware) FindItems(ctx context.Context, spaceId string, envI
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.FindItems")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.FindItems")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -137,7 +137,7 @@ func (m telemetryMiddleware) GetCollection(ctx context.Context, spaceId string,
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.GetCollection")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.GetCollection")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -173,7 +173,7 @@ func (m telemetryMiddleware) GetEnvironment(ctx context.Context, spaceId string,
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.GetEnvironment")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.GetEnvironment")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -208,7 +208,7 @@ func (m telemetryMiddleware) GetItem(ctx context.Context, spaceId string, envId
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.GetItem")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.GetItem")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -246,7 +246,7 @@ func (m telemetryMiddleware) ListCollections(ctx context.Context, spaceId string
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.ListCollections")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.ListCollections")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -281,7 +281,7 @@ func (m telemetryMiddleware) ListEnvironments(ctx context.Context, spaceId strin
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.ListEnvironments")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.ListEnvironments")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -315,7 +315,7 @@ func (m telemetryMiddleware) ListLocales(ctx context.Context, spaceId string) (l
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Delivery.ListLocales")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Delivery.ListLocales")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/environments/middleware/telemetry_middleware.go b/pkg/environments/middleware/telemetry_middleware.go
index 07ba728d1ef2e099594036436968d39b9a9271e1..7d21b26421085e1eacb177817a4c883c504252e6 100644
--- a/pkg/environments/middleware/telemetry_middleware.go
+++ b/pkg/environments/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements environments.Environments interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	environments.Environments
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base environments.Environments, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base environments.Environments, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base environments.Environments, instance string, spanDe
 
 	m := telemetryMiddleware{
 		Environments:   base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, env *environments.Envir
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -90,7 +90,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, envId s
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -124,7 +124,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId stri
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -159,7 +159,7 @@ func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (envs []*
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.List")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.List")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -193,7 +193,7 @@ func (m telemetryMiddleware) Migrate(ctx context.Context, spaceId string, envId
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.Migrate")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Migrate")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -228,7 +228,7 @@ func (m telemetryMiddleware) RemoveAlias(ctx context.Context, spaceId string, en
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.RemoveAlias")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.RemoveAlias")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -263,7 +263,7 @@ func (m telemetryMiddleware) SetAlias(ctx context.Context, spaceId string, envId
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.SetAlias")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.SetAlias")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -298,7 +298,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, env *environments.Envir
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Environments.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Environments.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/files/middleware/telemetry_middleware.go b/pkg/files/middleware/telemetry_middleware.go
index a93cbbcdceb4fea42b63f2af93cb5bd4523723b3..a65a52a5c8d2939d905580bd6008cb03df30b24d 100644
--- a/pkg/files/middleware/telemetry_middleware.go
+++ b/pkg/files/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements files.Files interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	files.Files
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base files.Files, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base files.Files, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base files.Files, instance string, spanDecorator ...fun
 
 	m := telemetryMiddleware{
 		Files:          base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) AbortUpload(ctx context.Context, upload *files.Mult
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Files.AbortUpload")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.AbortUpload")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -89,7 +89,7 @@ func (m telemetryMiddleware) CompleteUpload(ctx context.Context, upload *files.M
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Files.CompleteUpload")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.CompleteUpload")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -123,7 +123,7 @@ func (m telemetryMiddleware) DeleteFile(ctx context.Context, file *files.File) (
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Files.DeleteFile")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.DeleteFile")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -156,7 +156,7 @@ func (m telemetryMiddleware) GetFile(ctx context.Context, file *files.File) (f *
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Files.GetFile")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.GetFile")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -190,7 +190,7 @@ func (m telemetryMiddleware) MoveUpload(ctx context.Context, upload *files.Multi
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Files.MoveUpload")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.MoveUpload")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -224,7 +224,7 @@ func (m telemetryMiddleware) StartUpload(ctx context.Context, upload *files.Mult
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Files.StartUpload")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.StartUpload")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -258,7 +258,7 @@ func (m telemetryMiddleware) Upload(ctx context.Context, file *files.File) (u *f
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Files.Upload")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Files.Upload")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/invitations/middleware/telemetry_middleware.go b/pkg/invitations/middleware/telemetry_middleware.go
index 04077ce6d8c99ac7ad151e883f7e4d481705f06f..78bc0857c34b2cf4c45f37df1944c429e24bddba 100644
--- a/pkg/invitations/middleware/telemetry_middleware.go
+++ b/pkg/invitations/middleware/telemetry_middleware.go
@@ -22,13 +22,13 @@ import (
 // telemetryMiddleware implements invitations.Invitations interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	invitations.Invitations
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base invitations.Invitations, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base invitations.Invitations, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -36,7 +36,7 @@ func TelemetryMiddleware(base invitations.Invitations, instance string, spanDeco
 
 	m := telemetryMiddleware{
 		Invitations:    base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -57,7 +57,7 @@ func (m telemetryMiddleware) Accept(ctx context.Context, invitationId string, us
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Invitations.Accept")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Accept")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -91,7 +91,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, invitation *invitations
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Invitations.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -125,7 +125,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, invitationId string) (e
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Invitations.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -158,7 +158,7 @@ func (m telemetryMiddleware) Find(ctx context.Context, filter *invitations.Filte
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Invitations.Find")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Find")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -194,7 +194,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, invitationId string) (invi
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Invitations.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Invitations.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/items/middleware/telemetry_middleware.go b/pkg/items/middleware/telemetry_middleware.go
index 61ca591adc46aab635ff94ca27143929af9a076b..a3a79499707bafc09057875324d2a1db78853fda 100644
--- a/pkg/items/middleware/telemetry_middleware.go
+++ b/pkg/items/middleware/telemetry_middleware.go
@@ -22,13 +22,13 @@ import (
 // telemetryMiddleware implements items.Items interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	items.Items
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base items.Items, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base items.Items, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -36,7 +36,7 @@ func TelemetryMiddleware(base items.Items, instance string, spanDecorator ...fun
 
 	m := telemetryMiddleware{
 		Items:          base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -57,7 +57,7 @@ func (m telemetryMiddleware) Aggregate(ctx context.Context, spaceId string, envI
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Aggregate")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Aggregate")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -95,7 +95,7 @@ func (m telemetryMiddleware) AggregatePublished(ctx context.Context, spaceId str
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.AggregatePublished")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.AggregatePublished")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -133,7 +133,7 @@ func (m telemetryMiddleware) Archive(ctx context.Context, item *items.Item, opti
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Archive")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Archive")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -167,7 +167,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, item *items.Item, opts
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -202,7 +202,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, item *items.Item, optio
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -236,7 +236,7 @@ func (m telemetryMiddleware) Find(ctx context.Context, spaceId string, envId str
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Find")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Find")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -275,7 +275,7 @@ func (m telemetryMiddleware) FindArchived(ctx context.Context, spaceId string, e
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.FindArchived")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.FindArchived")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -314,7 +314,7 @@ func (m telemetryMiddleware) FindPublished(ctx context.Context, spaceId string,
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.FindPublished")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.FindPublished")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -353,7 +353,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId stri
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -391,7 +391,7 @@ func (m telemetryMiddleware) GetPublished(ctx context.Context, spaceId string, e
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.GetPublished")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.GetPublished")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -429,7 +429,7 @@ func (m telemetryMiddleware) GetRevision(ctx context.Context, spaceId string, en
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.GetRevision")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.GetRevision")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -468,7 +468,7 @@ func (m telemetryMiddleware) Introspect(ctx context.Context, item *items.Item, o
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Introspect")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Introspect")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -504,7 +504,7 @@ func (m telemetryMiddleware) ListRevisions(ctx context.Context, spaceId string,
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.ListRevisions")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.ListRevisions")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -542,7 +542,7 @@ func (m telemetryMiddleware) Publish(ctx context.Context, item *items.Item, opti
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Publish")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Publish")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -576,7 +576,7 @@ func (m telemetryMiddleware) Unarchive(ctx context.Context, item *items.Item, op
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Unarchive")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Unarchive")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -610,7 +610,7 @@ func (m telemetryMiddleware) Undelete(ctx context.Context, item *items.Item, opt
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Undelete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Undelete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -644,7 +644,7 @@ func (m telemetryMiddleware) Unpublish(ctx context.Context, item *items.Item, op
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Unpublish")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Unpublish")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -678,7 +678,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, item *items.Item, optio
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Items.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Items.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/locales/middleware/telemetry_middleware.go b/pkg/locales/middleware/telemetry_middleware.go
index 771e23f250fa7d1a45af2d1fc01262d7460dd8d6..ae10d4aa3ffc33a0687c3a9713ff9f5279ecd043 100644
--- a/pkg/locales/middleware/telemetry_middleware.go
+++ b/pkg/locales/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements locales.Locales interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	locales.Locales
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base locales.Locales, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base locales.Locales, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base locales.Locales, instance string, spanDecorator ..
 
 	m := telemetryMiddleware{
 		Locales:        base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, locale *locales.Locale)
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Locales.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Locales.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -90,7 +90,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, localeI
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Locales.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Locales.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -124,7 +124,7 @@ func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (locales
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Locales.List")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Locales.List")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/members/middleware/telemetry_middleware.go b/pkg/members/middleware/telemetry_middleware.go
index 978327d8c809e6c5ea41c28fe483ab156b3df84c..d8d53d43929a8ee65e2b75087522903cc3e2d268 100644
--- a/pkg/members/middleware/telemetry_middleware.go
+++ b/pkg/members/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements members.Members interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	members.Members
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base members.Members, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base members.Members, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base members.Members, instance string, spanDecorator ..
 
 	m := telemetryMiddleware{
 		Members:        base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, orgId string, userId strin
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Members.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -91,7 +91,7 @@ func (m telemetryMiddleware) ListMembers(ctx context.Context, orgId string) (mem
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Members.ListMembers")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.ListMembers")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -125,7 +125,7 @@ func (m telemetryMiddleware) ListOrganizations(ctx context.Context, userId strin
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Members.ListOrganizations")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.ListOrganizations")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -159,7 +159,7 @@ func (m telemetryMiddleware) Remove(ctx context.Context, orgId string, userId st
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Members.Remove")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.Remove")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -193,7 +193,7 @@ func (m telemetryMiddleware) RemoveAll(ctx context.Context, orgId string) (err e
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Members.RemoveAll")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.RemoveAll")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -226,7 +226,7 @@ func (m telemetryMiddleware) Set(ctx context.Context, orgId string, userId strin
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Members.Set")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Members.Set")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/organizations/middleware/telemetry_middleware.go b/pkg/organizations/middleware/telemetry_middleware.go
index f48b6a80a0a3b1d652d5147873700092039b2ecc..ac2e9d352812c62f59a6777ddb6009e6fa043039 100644
--- a/pkg/organizations/middleware/telemetry_middleware.go
+++ b/pkg/organizations/middleware/telemetry_middleware.go
@@ -22,13 +22,13 @@ import (
 // telemetryMiddleware implements organizations.Organizations interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	organizations.Organizations
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base organizations.Organizations, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base organizations.Organizations, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -36,7 +36,7 @@ func TelemetryMiddleware(base organizations.Organizations, instance string, span
 
 	m := telemetryMiddleware{
 		Organizations:  base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -57,7 +57,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, org *organizations.Orga
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Organizations.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -91,7 +91,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, orgId string) (err erro
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Organizations.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -124,7 +124,7 @@ func (m telemetryMiddleware) Find(ctx context.Context, filter *organizations.Fil
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Organizations.Find")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Find")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -160,7 +160,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, orgId string) (org *organi
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Organizations.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -194,7 +194,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, org *organizations.Orga
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Organizations.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Organizations.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/references/middleware/telemetry_middleware.go b/pkg/references/middleware/telemetry_middleware.go
index 58211a45ef77e373ef6cce0aa087d974b38c0b95..58f24355412f1f6e0d438641d133272090af235a 100644
--- a/pkg/references/middleware/telemetry_middleware.go
+++ b/pkg/references/middleware/telemetry_middleware.go
@@ -22,13 +22,13 @@ import (
 // telemetryMiddleware implements references.References interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	references.References
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base references.References, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base references.References, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -36,7 +36,7 @@ func TelemetryMiddleware(base references.References, instance string, spanDecora
 
 	m := telemetryMiddleware{
 		References:     base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -57,7 +57,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, envId stri
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "References.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "References.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -94,7 +94,7 @@ func (m telemetryMiddleware) Publish(ctx context.Context, spaceId string, envId
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "References.Publish")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "References.Publish")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/roles/middleware/telemetry_middleware.go b/pkg/roles/middleware/telemetry_middleware.go
index 28c6831861d2fe57206550dd58b2311143c36dcf..a44b876e46c660c8bdf3272aa003936c9badbdbb 100644
--- a/pkg/roles/middleware/telemetry_middleware.go
+++ b/pkg/roles/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements roles.Roles interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	roles.Roles
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base roles.Roles, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base roles.Roles, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base roles.Roles, instance string, spanDecorator ...fun
 
 	m := telemetryMiddleware{
 		Roles:          base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, role *roles.Role) (crea
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Roles.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -90,7 +90,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string, roleId
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Roles.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -124,7 +124,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string, roleId str
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Roles.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -159,7 +159,7 @@ func (m telemetryMiddleware) List(ctx context.Context, spaceId string) (roles []
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Roles.List")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.List")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -193,7 +193,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, role *roles.Role) (err
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Roles.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Roles.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/spaces/middleware/telemetry_middleware.go b/pkg/spaces/middleware/telemetry_middleware.go
index 66909e05aca7d9efbf4e2656f57ad0d54e495572..a6df52b3d444cfa95b3a1fa3383973c948447068 100644
--- a/pkg/spaces/middleware/telemetry_middleware.go
+++ b/pkg/spaces/middleware/telemetry_middleware.go
@@ -21,13 +21,13 @@ import (
 // telemetryMiddleware implements spaces.Spaces interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	spaces.Spaces
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base spaces.Spaces, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base spaces.Spaces, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -35,7 +35,7 @@ func TelemetryMiddleware(base spaces.Spaces, instance string, spanDecorator ...f
 
 	m := telemetryMiddleware{
 		Spaces:         base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -56,7 +56,7 @@ func (m telemetryMiddleware) AbortTransfer(ctx context.Context, spaceID string)
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.AbortTransfer")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.AbortTransfer")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -89,7 +89,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, space *spaces.Space) (c
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -123,7 +123,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, spaceId string) (err er
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -156,7 +156,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, spaceId string) (space *sp
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -190,7 +190,7 @@ func (m telemetryMiddleware) List(ctx context.Context, orgId string) (spaces []*
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.List")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.List")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -224,7 +224,7 @@ func (m telemetryMiddleware) ListTransfers(ctx context.Context, orgID string) (s
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.ListTransfers")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.ListTransfers")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -258,7 +258,7 @@ func (m telemetryMiddleware) Move(ctx context.Context, spaceID string, orgID str
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.Move")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Move")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -292,7 +292,7 @@ func (m telemetryMiddleware) Transfer(ctx context.Context, spaceID string, trans
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.Transfer")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Transfer")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -326,7 +326,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, space *spaces.Space) (e
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -359,7 +359,7 @@ func (m telemetryMiddleware) UpdateConfig(ctx context.Context, spaceId string, c
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Spaces.UpdateConfig")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Spaces.UpdateConfig")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
diff --git a/pkg/users/middleware/telemetry_middleware.go b/pkg/users/middleware/telemetry_middleware.go
index 0a5a0a53e0ee25dcca34a411bb86678b25c11a75..14dbc441ffab6033aaa80ecf33155fede2892408 100644
--- a/pkg/users/middleware/telemetry_middleware.go
+++ b/pkg/users/middleware/telemetry_middleware.go
@@ -22,13 +22,13 @@ import (
 // telemetryMiddleware implements users.Users interface instrumented with opentracing spans
 type telemetryMiddleware struct {
 	users.Users
-	instance       string
+	scope          string
 	requestMetrics *metrics.RequestMetrics
 	spanDecorator  func(span trace.Span, params, results map[string]interface{})
 }
 
 // TelemetryMiddleware returns telemetryMiddleware
-func TelemetryMiddleware(base users.Users, instance string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
+func TelemetryMiddleware(base users.Users, scope string, spanDecorator ...func(span trace.Span, params, results map[string]interface{})) telemetryMiddleware {
 	requestMetrics, err := metrics.GetRequestMetrics()
 	if err != nil {
 		panic(err)
@@ -36,7 +36,7 @@ func TelemetryMiddleware(base users.Users, instance string, spanDecorator ...fun
 
 	m := telemetryMiddleware{
 		Users:          base,
-		instance:       instance,
+		scope:          scope,
 		requestMetrics: requestMetrics,
 	}
 
@@ -57,7 +57,7 @@ func (m telemetryMiddleware) Create(ctx context.Context, create *users.User) (us
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Users.Create")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Create")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -91,7 +91,7 @@ func (m telemetryMiddleware) Delete(ctx context.Context, userId string) (err err
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Users.Delete")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Delete")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -124,7 +124,7 @@ func (m telemetryMiddleware) Find(ctx context.Context, filter *users.Filter, opt
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Users.Find")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Find")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -160,7 +160,7 @@ func (m telemetryMiddleware) Get(ctx context.Context, userId string) (user *user
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Users.Get")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Get")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -194,7 +194,7 @@ func (m telemetryMiddleware) GetByIdentity(ctx context.Context, identity string)
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Users.GetByIdentity")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.GetByIdentity")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)
@@ -228,7 +228,7 @@ func (m telemetryMiddleware) Update(ctx context.Context, update *users.User) (er
 	m.requestMetrics.Total.Add(ctx, 1, attributes)
 
 	start := time.Now()
-	ctx, span := otel.Tracer(m.instance).Start(ctx, "Users.Update")
+	ctx, span := otel.Tracer(m.scope).Start(ctx, "Users.Update")
 
 	defer func() {
 		m.requestMetrics.DurationMilliseconds.Record(ctx, time.Since(start).Milliseconds(), attributes)