gitlab-labkit 1.6.0 → 1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f0ded1c554ab0eb289f72738429db8f92ab18eb091fd7186663bdeb7d861cfc
-  data.tar.gz: 1b5276133b05752d03c3a58d36602e923cf69b8e040a71a22e194a971ca0bff6
+  metadata.gz: d4d14a6537b13d635133bda037b3c0d005c212414affacc546f6ba60cfc433c8
+  data.tar.gz: 40b259acc97328cf5a12156b8415308750d1ded3bda89b190aae6b66be66be50
 SHA512:
-  metadata.gz: 9e100693a48024f97d9314e2699c39be46a7dad631e3679e136b9477d9f6410a9ef86f346ed8a63777cae8e528332b6bc0adef41a5c8702ec84a62227ddb1e43
-  data.tar.gz: dd31347725dd09c313f8294238ab5e10faa50bcd2a94496bf77f80eaa1b5ea70bc2c194c4c1cb61991cf63c7a92386111abd7f36140de8d704d92c4e6ae6dc18
+  metadata.gz: 41fa558041ba46e4b3280fe37273e8a819b19c62a9c5539cfcb6200dc94b5f25dc2ed5f0dde861c8653dd02d0d91a0a948220729cd022ea346de7cb94cc64acc
+  data.tar.gz: a9966f49707dd37b1aa730e14745eb8f2181c5505e643531114e92d6c154c93ed3b185b1b5ab991663ed069a9ab4228a9ca8e8c64019f4a79d048130ef049086

data/.copier-answers.yml

@@ -3,7 +3,7 @@
 # See the project for instructions on how to update the project
 #
 # Changes here will be overwritten by Copier; NEVER EDIT MANUALLY
-_commit: v1.39.0
+_commit: v1.41.2
 _src_path: https://gitlab.com/gitlab-com/gl-infra/common-template-copier.git
 ee_licensed: false
 golang: false
@@ -11,6 +11,7 @@ helm: false
 initial_codeowners: '@reprazent @andrewn @mkaeppler @ayufan'
 jsonnet: false
 project_name: labkit-ruby
+release_platform: false
 ruby: true
 rubygem: true
 terraform: false

data/.releaserc.json

@@ -1,5 +1,11 @@
 {
-  "branches": ["master"],
+  "branches": [
+    {
+      "name": "+([0-9])-+([0-9])-stable",
+      "range": "${name.replace(/^(\\d+)-(\\d+)-stable$/, '$1.$2.x')}"
+    },
+    "master"
+  ],
   "plugins": [
     [
       "@semantic-release/commit-analyzer",

data/lib/labkit/net_http_publisher.rb

@@ -41,6 +41,8 @@ module Labkit
 
       start_time = ::Labkit::System.monotonic_time
 
+      inject_trace_context(request)
+
       ActiveSupport::Notifications.instrument ::Labkit::EXTERNAL_HTTP_NOTIFICATION_TOPIC, create_request_payload(request) do |payload|
         response =
           begin
@@ -57,7 +59,7 @@ module Labkit
 
     def create_request_payload(request)
       payload = {
-        method: request.method,
+        method: request.method
       }
 
       if request.uri.nil?
@@ -84,5 +86,22 @@ module Labkit
 
       payload
     end
+
+    def inject_trace_context(request)
+      return unless Labkit::Tracing.enabled?
+
+      tracer = Labkit::Tracing::TracingUtils.tracer
+      span = tracer.active_span
+      return if span.nil?
+
+      carrier = {}
+      tracer.inject_context(span, carrier)
+
+      carrier.each do |key, value|
+        request[key] = value
+      end
+    rescue StandardError
+      warn "Labkit::NetHttpPublisher: trace context propagation failed"
+    end
   end
 end

data/lib/labkit/tracing/README.md

@@ -35,13 +35,18 @@ export GITLAB_TRACING="otlp://localhost:4318"
 
 **Automatic Initialization**
 
-When `GITLAB_TRACING` is set, LabKit automatically creates and configures a tracer when the gem is loaded. No manual initialization is required in most cases.
+When `GITLAB_TRACING` is set, LabKit automatically creates and configures a tracer:
+
+- **Rails applications**: Railtie automatically inserts Labkit::Tracing::RackMiddleware into the middleware stack
+- **Non-Rails applications**: Tracer is auto-initialized, but `Labkit::Tracing::RackMiddleware` must be manually added to your middleware stack for HTTP request tracing (see [Rack Middleware](#rack-middleware))
 
 Auto-initialization provides:
-- Automatic tracer creation with connection string settings
+- Automatic tracer creation with connection string settings (sampler, exporter, service name)
 - Service name from `service_name` query parameter (defaults to `"labkit-service"`)
-- All available OpenTelemetry instrumentation enabled by default (`c.use_all()`)
-- LabKit-specific instrumentation enabled automatically:
+- Selective OpenTelemetry instrumentation for components that don't conflict with LabKit:
+  - `ConcurrentRuby`, `Net::HTTP`, `ActionPack`, `ActionMailer`, `ActiveJob`
+- LabKit's own instrumentation for components it handles directly:
+  - HTTP request tracing (RackMiddleware for Rails)
   - Rails components (ActiveRecord, ActionView, ActiveSupport) - if Rails is available
   - Redis instrumentation - if Redis gem is loaded
   - External HTTP instrumentation (Net::HTTP, Excon, HTTPClient)
@@ -73,6 +78,7 @@ The following connection string formats and query parameters are supported:
   - **Behavior**: Outputs spans immediately to stdout with no remote export
   - **Benefits**: No external collector required, instant feedback, simple debugging
 
+
 ### Sampling
 
 **Default Behavior:** When no sampler is specified, probabilistic sampling is used with a **0.1% sample rate** (1 in 1000 traces).
@@ -159,7 +165,7 @@ This seamless integration means you can:
 
 ### Automatic Initialization (Default Behavior)
 
-When `GITLAB_TRACING` is set, LabKit automatically creates and configures a tracer when the gem loads:
+When `GITLAB_TRACING` is set, LabKit automatically creates and configures a tracer:
 
 ```bash
 # Set environment variable with service name
@@ -169,14 +175,23 @@ export GITLAB_TRACING="otlp://localhost:4318?service_name=my-api&sampler=probabi
 export GITLAB_TRACING="otlp://localhost:4318"
 ```
 
+**Rails Applications:**
+- Initialization happens automatically during Rails boot via Railtie
+- Runs after all other gem initializers (including `opentelemetry-instrumentation-rails`)
+- LabKit's TracerProvider is the final configuration used by the application
+- **No application code changes required** - just set the environment variable
+
+**Non-Rails Applications (Sinatra, Grape, standalone Ruby):**
+- Tracer auto-initialization happens automatically when `require 'gitlab-labkit'` is called.
+- However, you must manually add `Labkit::Tracing::RackMiddleware` to your middleware stack for HTTP request tracing. See the [Rack Middleware](#rack-middleware) section for details.
+
 Auto-initialization:
 - Creates tracer with connection string settings (sampler, exporter, endpoints)
 - Uses service name from `service_name` query parameter (defaults to `"labkit-service"`)
-- Enables all available OpenTelemetry instrumentation
+- Enables selective OpenTelemetry instrumentation (non-conflicting with LabKit's own)
+- Enables LabKit instrumentation for ActiveRecord, ActionView, ActiveSupport, Redis, and External HTTP
 - Sets up the global `OpenTelemetry.tracer_provider`
 
-**No application code changes required** - just set the environment variable.
-
 ### Automatic Rails Middleware Insertion
 
 When using Rails, the `Labkit::Tracing::RackMiddleware` is automatically inserted into your middleware stack when `GITLAB_TRACING` is set. No manual configuration needed!
@@ -214,8 +229,8 @@ You can override auto-initialization by calling `Factory.create_tracer` in your
 # config/initializers/tracing.rb
 # Override auto-initialization with custom configuration
 Labkit::Tracing::Factory.create_tracer("my-custom-service", ENV["GITLAB_TRACING"]) do |c|
-  # Selective instrumentation instead of c.use_all()
-  c.use 'OpenTelemetry::Instrumentation::Rails'
+  # Custom OTel instrumentation
+  c.use 'OpenTelemetry::Instrumentation::ConcurrentRuby'
   c.use 'OpenTelemetry::Instrumentation::Sidekiq'
 
   # Add custom span processors
@@ -232,7 +247,7 @@ end
 ```
 
 **When to use manual initialization:**
-- You need selective instrumentation (not `c.use_all()`)
+- You need different OTel instrumentations than the defaults
 - You need custom span processors
 - You need to add resource attributes
 - You want to override the service name from code instead of the connection string
@@ -289,11 +304,16 @@ end
 
 ### Initialization Order and Precedence
 
-**Auto-initialization:**
-1. Runs when the gem is loaded (`require 'gitlab-labkit'`)
+**Auto-initialization (all applications):**
+1. Runs automatically when `require 'gitlab-labkit'` is called
 2. Only runs if `GITLAB_TRACING` environment variable is set
 3. Uses `service_name` query parameter or defaults to `"labkit-service"`
-4. Attempts to enable all instrumentation with `c.use_all()`
+4. Enables selective OpenTelemetry instrumentation (ConcurrentRuby, Net::HTTP, ActionPack, ActionMailer, ActiveJob) to avoid conflicts with LabKit's own instrumentation
+5. Enables LabKit instrumentation for ActiveRecord, ActionView, ActiveSupport, Redis, and External HTTP
+
+**Additional Rails behavior:**
+1. Railtie runs after user config initializers (via `initializer ... after: :load_config_initializers`)
+2. Automatically inserts `Labkit::Tracing::RackMiddleware` into the middleware stack
 
 **Manual initialization:**
 1. Runs in your application initializer (e.g., `config/initializers/tracing.rb`)
@@ -308,7 +328,7 @@ end
    - Span processors with OTLP exporter
 
 2. **Configuration block** runs second and can:
-   - Add automatic instrumentation (`use`, `use_all`)
+   - Add automatic instrumentation (`use`)
    - Add additional span processors
    - Merge additional resource attributes
    - Override service_name if explicitly set in the block
@@ -570,8 +590,13 @@ If you need to add custom metadata (deployment environment, version, etc.), over
 # config/initializers/tracing.rb
 
 Labkit::Tracing::Factory.create_tracer("my-rails-app", ENV["GITLAB_TRACING"]) do |c|
-  # Enable all available OpenTelemetry instrumentation
-  c.use_all()
+  # Selective instrumentation (avoid conflicting with LabKit's own instrumentation
+  # for ActiveRecord, ActionView, ActiveSupport, Redis, Rack, and Sidekiq)
+  c.use("OpenTelemetry::Instrumentation::ConcurrentRuby")
+  c.use("OpenTelemetry::Instrumentation::Net::HTTP")
+  c.use("OpenTelemetry::Instrumentation::ActionPack") if defined?(ActionPack)
+  c.use("OpenTelemetry::Instrumentation::ActionMailer") if defined?(ActionMailer)
+  c.use("OpenTelemetry::Instrumentation::ActiveJob") if defined?(ActiveJob)
 
   # Add deployment metadata
   c.resource = c.resource.merge(
@@ -588,18 +613,18 @@ end
 
 Note: Middleware is still automatically inserted even with custom tracer initialization.
 
-### With Selective Instrumentation (Manual Override)
+### With Custom Instrumentation (Manual Override)
 
-If you want to control exactly which components are instrumented instead of using `c.use_all()`, override tracer initialization:
+If you want to control exactly which OTel components are instrumented, override tracer initialization:
 
 **Important:** When you manually call `Factory.create_tracer`, auto-initialization still runs but is replaced by your manual configuration. The LabKit-specific instrumentation (Rails, Redis, ExternalHttp) is still automatically enabled unless you explicitly disable auto-initialization.
 
 ```ruby
 # config/initializers/tracing.rb
-# Override auto-initialization for selective OpenTelemetry instrumentation
+# Override auto-initialization for custom OpenTelemetry instrumentation
 Labkit::Tracing::Factory.create_tracer("my-rails-app", ENV["GITLAB_TRACING"]) do |c|
-  # Selective OpenTelemetry instrumentation (instead of c.use_all())
-  c.use 'OpenTelemetry::Instrumentation::Rails'
+  # Only enable the OTel instrumentations you need
+  c.use 'OpenTelemetry::Instrumentation::ConcurrentRuby'
   c.use 'OpenTelemetry::Instrumentation::Sidekiq'
 end
 
@@ -642,9 +667,9 @@ If you're not seeing HTTP request traces in Rails:
    ```
 
 2. Check Rails logs for auto-insertion message:
-   ```
-   Labkit::Tracing: Automatically inserted RackMiddleware after Rails::Rack::Logger
-   ```
+    ```
+    Labkit::Tracing::RackMiddleware automatically inserted after Labkit::Middleware::Rack
+    ```
 
 3. If using custom middleware positioning, verify the order is correct:
    ```bash

data/lib/labkit/tracing/abstract_instrumenter.rb

@@ -7,27 +7,26 @@ module Labkit
     # https://edgeapi.rubyonrails.org/classes/ActiveSupport/Notifications/Instrumenter.html#method-c-new
     class AbstractInstrumenter
       def start(_name, _id, payload)
-        scope = Labkit::Tracing::TracingUtils.tracer.start_active_span(span_name(payload))
+        span_wrapper = Labkit::Tracing::TracingUtils.tracer.start_active_span(span_name(payload))
 
-        scope_stack.push scope
+        scope_stack.push span_wrapper
       end
 
       def finish(_name, _id, payload)
-        scope = scope_stack.pop
-        span = scope.span
+        span_wrapper = scope_stack.pop
 
-        Labkit::Tracing::TracingUtils.log_common_fields_on_span(span, span_name(payload))
+        Labkit::Tracing::TracingUtils.log_common_fields_on_span(span_wrapper, span_name(payload))
 
         # exception_object is the standard exception payload from ActiveSupport::Notifications
         # https://github.com/rails/rails/blob/v6.0.3.1/activesupport/lib/active_support/notifications/instrumenter.rb#L26
         exception = payload[:exception_object].presence || payload[:exception].presence
-        Labkit::Tracing::TracingUtils.log_exception_on_span(span, exception)
+        span_wrapper.set_error(exception)
 
         tags(payload).each do |k, v|
-          span.set_tag(k, v)
+          span_wrapper.set_tag(k, v)
         end
 
-        scope.close
+        span_wrapper.close
       end
 
       def scope_stack

data/lib/labkit/tracing/adapters/opentelemetry_span.rb

@@ -40,6 +40,10 @@ module Labkit
           end
         end
 
+        def close(**opts)
+          finish(**opts)
+        end
+
         def context
           span.context
         end

data/lib/labkit/tracing/adapters/opentelemetry_tracer.rb

@@ -91,6 +91,18 @@ module Labkit
             @token = token
           end
 
+          def set_tag(key, value)
+            span.set_tag(key, value)
+          end
+
+          def set_error(exception)
+            span.set_error(exception)
+          end
+
+          def log_event(name, **attributes)
+            span.log_event(name, **attributes)
+          end
+
           def close
             @raw_span.finish
             OpenTelemetry::Context.detach(@token)

data/lib/labkit/tracing/adapters/opentracing_span.rb

@@ -41,6 +41,10 @@ module Labkit
           scope&.close
         end
 
+        def close
+          finish
+        end
+
         def context
           span.context
         end

data/lib/labkit/tracing/adapters/opentracing_tracer.rb

@@ -34,15 +34,18 @@ module Labkit
         end
 
         def active_span
-          OpenTracing.active_span
+          span = OpenTracing.active_span
+          OpentracingSpan.new(span) if span
         end
 
         def start_active_span(operation_name, tags: nil)
-          if tags
-            OpenTracing.start_active_span(operation_name, tags: tags)
-          else
-            OpenTracing.start_active_span(operation_name)
-          end
+          scope = if tags
+                    OpenTracing.start_active_span(operation_name, tags: tags)
+                  else
+                    OpenTracing.start_active_span(operation_name)
+                  end
+
+          OpentracingSpan.new(scope)
         end
       end
     end

data/lib/labkit/tracing/auto_initialize.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "cgi"
+require "uri"
 require "active_support/core_ext/object/blank"
 
 module Labkit
@@ -9,9 +9,16 @@ module Labkit
       def self.detect_service_name(connection_string)
         return Labkit::Tracing::DEFAULT_SERVICE_NAME unless connection_string
 
-        if connection_string =~ /[?&]service_name=([^&]+)/
-          CGI.unescape(Regexp.last_match(1))
-        else
+        begin
+          parsed = URI.parse(connection_string)
+          options = TracingUtils.parse_query_string(parsed.query)
+
+          return options[:service_name] if options[:service_name]
+
+          warn "Labkit::Tracing: service_name not found in connection string, using default: '#{Labkit::Tracing::DEFAULT_SERVICE_NAME}'"
+          Labkit::Tracing::DEFAULT_SERVICE_NAME
+        rescue URI::InvalidURIError => e
+          warn "Labkit::Tracing: Invalid connection string (#{e.message}), using default service name: '#{Labkit::Tracing::DEFAULT_SERVICE_NAME}'"
           Labkit::Tracing::DEFAULT_SERVICE_NAME
         end
       end
@@ -22,9 +29,24 @@ module Labkit
 
         service_name = detect_service_name(connection_string)
 
+        require "opentelemetry/instrumentation/concurrent_ruby"
+        require "opentelemetry/instrumentation/net/http"
+        require "opentelemetry/instrumentation/action_pack" if defined?(ActionPack)
+        require "opentelemetry/instrumentation/action_mailer" if defined?(ActionMailer)
+        require "opentelemetry/instrumentation/active_job" if defined?(ActiveJob)
+
         Factory.create_tracer(service_name, connection_string) do |c|
-          require "opentelemetry/instrumentation/all"
-          c.use_all
+          # Enable only non-conflicting instrumentations
+          # Exclude: ActiveSupport, ActiveRecord, ActionView, Redis, Rack, Sidekiq
+          # (LabKit provides its own instrumentation for these via AbstractInstrumenter)
+
+          # Core instrumentations
+          c.use("OpenTelemetry::Instrumentation::ConcurrentRuby")
+
+          # Rails components that don't conflict with LabKit
+          c.use("OpenTelemetry::Instrumentation::ActionPack") if defined?(ActionPack)
+          c.use("OpenTelemetry::Instrumentation::ActionMailer") if defined?(ActionMailer)
+          c.use("OpenTelemetry::Instrumentation::ActiveJob") if defined?(ActiveJob)
         end
 
         enable_labkit_instrumentation

data/lib/labkit/tracing/external_http/request_instrumenter.rb

@@ -12,20 +12,11 @@ module Labkit
         def tags(payload)
           # Duration is calculated by start and end time
           # Exception is already captured in lib/labkit/tracing/tracing_utils.rb
-          tags = {
-            "component" => "external_http",
-            "method" => payload[:method],
-            "code" => payload[:code],
-            "host" => payload[:host],
-            "port" => payload[:port],
-            "path" => payload[:path],
-            "scheme" => payload[:scheme],
-          }
+          tags = payload.slice(:method, :code, :host, :port, :path, :scheme, :proxy_host, :proxy_port)
+          tags.transform_keys!(&:name)
+          tags["component"] = "external_http"
 
-          unless payload[:proxy_host].nil?
-            tags["proxy_host"] = payload[:proxy_host]
-            tags["proxy_port"] = payload[:proxy_port]
-          end
+          tags.compact!
 
           tags
         end

data/lib/labkit/tracing/open_telemetry_factory.rb

@@ -79,14 +79,10 @@ module Labkit
               yield(c)
             end
 
-            # SDK.configure doesn't expose sampler configuration directly
-            # We need to replace the tracer provider to set the sampler
-            # This is a known limitation of the OpenTelemetry Ruby SDK
             current_provider = OpenTelemetry.tracer_provider
             return unless current_provider.is_a?(OpenTelemetry::SDK::Trace::TracerProvider)
 
-            # Create new provider with sampler, preserving resource from SDK.configure
-            create_and_configure_provider(current_provider.resource, sampler, exporter)
+            current_provider.sampler = sampler
           else
             create_and_configure_provider(base_resource, sampler, exporter)
           end
@@ -175,7 +171,7 @@ module Labkit
           parsed = URI.parse(connection_string)
 
           # Parse query parameters for additional options
-          options = parse_query(parsed.query)
+          options = TracingUtils.parse_query_string(parsed.query)
 
           # Handle console exporter (special case - no endpoint needed)
           if parsed.host == "console"
@@ -206,12 +202,6 @@ module Labkit
 
           endpoint
         end
-
-        def parse_query(query)
-          return {} unless query
-
-          CGI.parse(query).symbolize_keys.transform_values(&:first)
-        end
       end
     end
   end

data/lib/labkit/tracing/open_tracing_factory.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "cgi"
-
 module Labkit
   module Tracing
     class OpenTracingFactory
@@ -26,17 +24,10 @@ module Labkit
 
         raise "Invalid tracing connection string" unless valid_uri?(parsed)
 
-        { driver_name: parsed.host, options: parse_query(parsed.query) }
+        { driver_name: parsed.host, options: TracingUtils.parse_query_string(parsed.query) }
       end
       private_class_method :parse_connection_string
 
-      def self.parse_query(query)
-        return {} unless query
-
-        CGI.parse(query).symbolize_keys.transform_values(&:first)
-      end
-      private_class_method :parse_query
-
       def self.valid_uri?(uri)
         return false unless uri
 

data/lib/labkit/tracing/rails/action_view/render_template_instrumenter.rb

@@ -16,7 +16,12 @@ module Labkit
           end
 
           def tags(payload)
-            { "component" => COMPONENT_TAG, "template.id" => payload[:identifier], "template.layout" => payload[:layout] }
+            tags = { "component" => COMPONENT_TAG }
+            # OpenTelemetry rejects nil attributes, and error templates may not
+            # have a layout (e.g., public/406-unsupported-browser.html).
+            tags["template.id"] = payload[:identifier] if payload[:identifier]
+            tags["template.layout"] = payload[:layout] if payload[:layout]
+            tags
           end
         end
       end

data/lib/labkit/tracing/rails/active_record/sql_instrumenter.rb

@@ -19,15 +19,20 @@ module Labkit
               fingerprint = Labkit::Logging::Sanitizer.sql_fingerprint(sql)
             end
 
-            {
+            tags = {
               "component" => COMPONENT_TAG,
               "span.kind" => "client",
               "db.type" => "sql",
-              "db.connection_id" => payload[:connection_id],
               "db.cached" => payload[:cached] || false,
-              "db.statement" => sql,
-              "db.statement_fingerprint" => fingerprint,
             }
+
+            # OpenTelemetry rejects nil attributes, so only add statement fields
+            # when ActiveRecord supplies SQL (schema events may omit it).
+            tags["db.statement"] = sql if sql
+            tags["db.statement_fingerprint"] = fingerprint if fingerprint
+            tags["db.connection_id"] = payload[:connection_id] if payload[:connection_id]
+
+            tags
           end
         end
       end

data/lib/labkit/tracing/tracing_utils.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "cgi"
 require "active_support/core_ext/string/starts_ends_with"
 require "opentracing"
 
@@ -16,7 +17,7 @@ module Labkit
           begin
             yield span
           rescue StandardError => e
-            log_exception_on_span(span, e)
+            span.set_error(e)
             raise e
           end
         end
@@ -55,7 +56,7 @@ module Labkit
         span = tracer.start_span(operation_name, child_of: child_of, tags: tags, start_time: start_time)
 
         log_common_fields_on_span(span, operation_name)
-        log_exception_on_span(span, exception) if exception
+        span.set_error(exception)
 
         span.finish(end_timestamp: end_time)
       end
@@ -68,11 +69,6 @@ module Labkit
         span.log_event("stack", stack: caller.join('\n')) if include_stacktrace?(operation_name)
       end
 
-      # Add exception logging to a span
-      def self.log_exception_on_span(span, exception)
-        span.set_error(exception)
-      end
-
       def self.include_stacktrace?(operation_name)
         @include_stacktrace ||= Hash.new do |result, name|
           result[name] = Tracing.stacktrace_operations.any? { |stacktrace_operation| name.starts_with?(stacktrace_operation) }
@@ -80,6 +76,12 @@ module Labkit
 
         @include_stacktrace[operation_name]
       end
+
+      def self.parse_query_string(query)
+        return {} unless query
+
+        CGI.parse(query).symbolize_keys.transform_values(&:first)
+      end
     end
   end
 end

data/lib/labkit/tracing.rb

@@ -30,7 +30,9 @@ module Labkit
       autoload :OpentracingTracer, "labkit/tracing/adapters/opentracing_tracer"
     end
 
-    DEFAULT_SERVICE_NAME = :'labkit-service'
+    # Must be a String, not Symbol, as OpenTelemetry requires resource attribute values
+    # to be strings, integers, floats, or booleans
+    DEFAULT_SERVICE_NAME = "labkit-service"
 
     # Module-level attribute for storing the configured service name
     # Set by Factory.create_tracer when a tracer is created

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-labkit
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.1
 platform: ruby
 authors:
 - Andrew Newdigate