gitlab-labkit 1.4.0 → 1.5.0

data/lib/labkit/tracing/abstract_instrumenter.rb

@@ -7,7 +7,7 @@ module Labkit
     # https://edgeapi.rubyonrails.org/classes/ActiveSupport/Notifications/Instrumenter.html#method-c-new
     class AbstractInstrumenter
       def start(_name, _id, payload)
-        scope = OpenTracing.start_active_span(span_name(payload))
+        scope = Labkit::Tracing::TracingUtils.tracer.start_active_span(span_name(payload))
 
         scope_stack.push scope
       end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Adapters
+      class BaseSpan
+        attr_reader :span
+
+        def initialize(span)
+          @span = span
+        end
+
+        def set_tag(_key, _value)
+          raise NotImplementedError, "#{self.class.name}#set_tag must be implemented"
+        end
+
+        def log_event(_name, **_attributes)
+          raise NotImplementedError, "#{self.class.name}#log_event must be implemented"
+        end
+
+        def set_error(_exception)
+          raise NotImplementedError, "#{self.class.name}#set_error must be implemented"
+        end
+
+        def finish(**_opts)
+          raise NotImplementedError, "#{self.class.name}#finish must be implemented"
+        end
+
+        def context
+          raise NotImplementedError, "#{self.class.name}#context must be implemented"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Adapters
+      class BaseTracer
+        attr_reader :tracer
+
+        def initialize(tracer)
+          @tracer = tracer
+        end
+
+        def start_span(_operation_name, child_of: nil, tags: {}, start_time: nil)
+          raise NotImplementedError, "#{self.class.name}#start_span must be implemented"
+        end
+
+        def in_span(_operation_name, child_of: nil, tags: {}, &_block)
+          raise NotImplementedError, "#{self.class.name}#in_span must be implemented"
+        end
+
+        def extract_context(_carrier, format: nil)
+          raise NotImplementedError, "#{self.class.name}#extract_context must be implemented"
+        end
+
+        def inject_context(_span_context, _carrier, format: nil)
+          raise NotImplementedError, "#{self.class.name}#inject_context must be implemented"
+        end
+
+        def active_span
+          raise NotImplementedError, "#{self.class.name}#active_span must be implemented"
+        end
+
+        def start_active_span(_operation_name, tags: nil)
+          raise NotImplementedError, "#{self.class.name}#start_active_span must be implemented"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# Internal adapter for OpenTelemetry span compatibility.
+# This is not part of the public Labkit API.
+#
+# Applications should use OpenTelemetry APIs directly via:
+#   - Labkit::Tracing.tracer (returns OpenTelemetry::Trace::Tracer)
+#   - Labkit::Tracing.current_span (returns OpenTelemetry::Trace::Span)
+#
+# These adapters exist for:
+#   - Internal Labkit instrumentation (Rails, Redis, etc.)
+#   - Backward compatibility with OpenTracing connections
+#
+# @api private
+
+module Labkit
+  module Tracing
+    module Adapters
+      class OpentelemetrySpan < BaseSpan
+        def set_tag(key, value)
+          span.set_attribute(key, value)
+        end
+
+        def log_event(name, **attributes)
+          span.add_event(name, attributes: stringify_keys(attributes))
+        end
+
+        def set_error(exception)
+          return if exception.blank?
+
+          span.set_attribute("error", true)
+          span.add_event("exception", attributes: stringify_keys(kv_tags_for_exception(exception)))
+        end
+
+        def finish(**opts)
+          if opts[:end_timestamp]
+            span.finish(end_timestamp: opts[:end_timestamp])
+          else
+            span.finish
+          end
+        end
+
+        def context
+          span.context
+        end
+
+        private
+
+        def stringify_keys(hash)
+          hash.transform_keys(&:to_s)
+        end
+
+        def kv_tags_for_exception(exception)
+          case exception
+          when Exception
+            {
+              event: "error",
+              'error.kind': exception.class.to_s,
+              message: Labkit::Logging::Sanitizer.sanitize_field(exception.message),
+              stack: exception.backtrace&.join('\n')
+            }
+          else
+            {
+              event: "error",
+              'error.kind': exception.class.to_s,
+              'error.object': Labkit::Logging::Sanitizer.sanitize_field(exception.to_s)
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+# Internal adapter for OpenTelemetry tracer compatibility.
+# This is not part of the public Labkit API.
+#
+# Applications should use OpenTelemetry APIs directly via:
+#   - Labkit::Tracing.tracer (returns OpenTelemetry::Trace::Tracer)
+#   - Labkit::Tracing.current_span (returns OpenTelemetry::Trace::Span)
+#
+# These adapters exist for:
+#   - Internal Labkit instrumentation (Rails, Redis, etc.)
+#   - Backward compatibility with OpenTracing connections
+#
+# @api private
+
+module Labkit
+  module Tracing
+    module Adapters
+      class OpentelemetryTracer < BaseTracer
+        def start_span(operation_name, child_of: nil, tags: {}, start_time: nil)
+          attributes = tags || {}
+          opts = { attributes: attributes }
+          opts[:with_parent] = child_of if child_of
+          opts[:start_timestamp] = start_time if start_time
+
+          span = tracer.start_span(operation_name, **opts)
+          OpentelemetrySpan.new(span)
+        end
+
+        def in_span(operation_name, child_of: nil, tags: {})
+          attributes = tags || {}
+
+          if child_of
+            span = tracer.start_span(operation_name, with_parent: child_of, attributes: attributes)
+            ctx = OpenTelemetry::Trace.context_with_span(span)
+
+            result = nil
+            OpenTelemetry::Context.with_current(ctx) do
+              adapter = OpentelemetrySpan.new(span)
+              result = yield(adapter)
+            end
+
+            span.finish
+            result
+          else
+            tracer.in_span(operation_name, attributes: attributes) do |span|
+              adapter = OpentelemetrySpan.new(span)
+              yield(adapter)
+            end
+          end
+        end
+
+        def extract_context(carrier, format: nil) # rubocop:disable Lint/UnusedMethodArgument
+          # Format parameter is ignored for OpenTelemetry - propagation format is configured
+          # globally via OTEL_PROPAGATORS environment variable, not per-call like OpenTracing.
+          # The parameter exists only for BaseTracer API compatibility.
+          OpenTelemetry.propagation.extract(carrier)
+        end
+
+        def inject_context(span_wrapper, carrier, format: nil) # rubocop:disable Lint/UnusedMethodArgument
+          # Format parameter is ignored for OpenTelemetry - propagation format is configured
+          # globally via OTEL_PROPAGATORS environment variable, not per-call like OpenTracing.
+          # The parameter exists only for BaseTracer API compatibility.
+          #
+          # span_wrapper is expected to be a BaseSpan (e.g., OpentelemetrySpan) that wraps
+          # the actual OpenTelemetry span. We unwrap it to get the OTel span object.
+          span = span_wrapper.respond_to?(:span) ? span_wrapper.span : span_wrapper
+          context = OpenTelemetry::Trace.context_with_span(span)
+          OpenTelemetry.propagation.inject(carrier, context: context)
+        end
+
+        def active_span
+          OpenTelemetry::Trace.current_span
+        end
+
+        def start_active_span(operation_name, tags: nil)
+          attributes = tags || {}
+          raw_span = tracer.start_span(operation_name, attributes: attributes)
+          ctx = OpenTelemetry::Trace.context_with_span(raw_span)
+          token = OpenTelemetry::Context.attach(ctx)
+
+          OpenTelemetryScope.new(raw_span, token)
+        end
+
+        class OpenTelemetryScope
+          attr_reader :span
+
+          def initialize(raw_span, token)
+            @span = OpentelemetrySpan.new(raw_span)
+            @raw_span = raw_span
+            @token = token
+          end
+
+          def close
+            @raw_span.finish
+            OpenTelemetry::Context.detach(@token)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Adapters
+      class OpentracingSpan < BaseSpan
+        attr_reader :scope
+
+        def initialize(span_or_scope)
+          if span_or_scope.respond_to?(:span)
+            @scope = span_or_scope
+            @span = span_or_scope.span
+          else
+            @scope = nil
+            @span = span_or_scope
+          end
+        end
+
+        def set_tag(key, value)
+          span.set_tag(key, value)
+        end
+
+        def log_event(name, **attributes)
+          span.log_kv(**attributes, event: name)
+        end
+
+        def set_error(exception)
+          return if exception.blank?
+
+          span.set_tag("error", true)
+          span.log_kv(**kv_tags_for_exception(exception))
+        end
+
+        def finish(**opts)
+          if opts[:end_timestamp]
+            span.finish(end_time: opts[:end_timestamp])
+          else
+            span.finish
+          end
+
+          scope&.close
+        end
+
+        def context
+          span.context
+        end
+
+        private
+
+        def kv_tags_for_exception(exception)
+          case exception
+          when Exception
+            {
+              event: "error",
+              'error.kind': exception.class.to_s,
+              message: Labkit::Logging::Sanitizer.sanitize_field(exception.message),
+              stack: exception.backtrace&.join('\n')
+            }
+          else
+            {
+              event: "error",
+              'error.kind': exception.class.to_s,
+              'error.object': Labkit::Logging::Sanitizer.sanitize_field(exception.to_s)
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Adapters
+      class OpentracingTracer < BaseTracer
+        def start_span(operation_name, child_of: nil, tags: {}, start_time: nil)
+          opts = {}
+          opts[:child_of] = child_of if child_of
+          opts[:tags] = tags if tags
+          opts[:start_time] = start_time if start_time
+
+          span = tracer.start_span(operation_name, **opts)
+          OpentracingSpan.new(span)
+        end
+
+        def in_span(operation_name, child_of: nil, tags: {})
+          scope = tracer.start_active_span(operation_name, child_of: child_of, tags: tags)
+          adapter = OpentracingSpan.new(scope)
+
+          begin
+            yield(adapter)
+          ensure
+            adapter.finish
+          end
+        end
+
+        def extract_context(carrier, format: OpenTracing::FORMAT_TEXT_MAP)
+          tracer.extract(format, carrier)
+        end
+
+        def inject_context(span_context, carrier, format: OpenTracing::FORMAT_TEXT_MAP)
+          tracer.inject(span_context, format, carrier)
+        end
+
+        def active_span
+          OpenTracing.active_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
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/auto_initialize.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "active_support/core_ext/object/blank"
+
+module Labkit
+  module Tracing
+    module AutoInitialize
+      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
+          Labkit::Tracing::DEFAULT_SERVICE_NAME
+        end
+      end
+
+      def self.initialize!
+        connection_string = ENV.fetch("GITLAB_TRACING", nil)
+        return if connection_string.nil? || connection_string.empty?
+
+        service_name = detect_service_name(connection_string)
+
+        Factory.create_tracer(service_name, connection_string) do |c|
+          require "opentelemetry/instrumentation/all"
+          c.use_all
+        end
+
+        enable_labkit_instrumentation
+      rescue StandardError => e
+        warn "Labkit::Tracing auto-initialization failed: #{e.message}"
+      end
+
+      def self.enable_labkit_instrumentation
+        Rails::ActiveRecord::Subscriber.instrument if defined?(::ActiveRecord)
+        Rails::ActionView::Subscriber.instrument if defined?(::ActionView)
+        Rails::ActiveSupport::Subscriber.instrument if defined?(::ActiveSupport)
+        Redis.instrument if defined?(::Redis)
+        ExternalHttp.instrument
+      rescue StandardError => e
+        warn "Labkit::Tracing: LabKit instrumentation setup failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/labkit/tracing/factory.rb

@@ -1,58 +1,46 @@
 # frozen_string_literal: true
 
-require "cgi"
-
 module Labkit
   module Tracing
     # Factory provides tools for setting up and configuring the
     # distributed tracing system within the process, given the
     # tracing connection string
     class Factory
-      OPENTRACING_SCHEME = "opentracing"
-
-      def self.create_tracer(service_name, connection_string)
+      # When the probabilistic sampler is used, by default 0.1% of requests will be traced
+      DEFAULT_PROBABILISTIC_RATE = 0.001
+
+      # @param service_name [String] The service name for the tracer
+      # @param connection_string [String] The connection string (e.g., "otlp://localhost:4318")
+      # @yield [config] Optional configuration block for OpenTelemetry SDK customization (OTLP only)
+      # @yieldparam config [OpenTelemetry::SDK::Configurator] The SDK configurator
+      # @return [Tracer, nil] The configured tracer or nil if initialization fails
+      def self.create_tracer(service_name, connection_string, &config_block)
         return unless connection_string.present?
 
-        begin
-          opentracing_details = parse_connection_string(connection_string)
-          driver_name = opentracing_details[:driver_name]
-
-          case driver_name
-          when "jaeger"
-            JaegerFactory.create_tracer(service_name, opentracing_details[:options])
+        tracer =
+          if Tracing.otlp_connection?(connection_string)
+            OpenTelemetryFactory.create_tracer(service_name, connection_string, &config_block)
+          elsif Tracing.opentracing_connection?(connection_string)
+            warn_opentracing_block_ignored if config_block
+            OpenTracingFactory.create_tracer(service_name, connection_string)
           else
-            raise "Unknown driver: #{driver_name}"
+            raise "Unknown protocol"
           end
 
-          # Can't create the tracer? Warn and continue sans tracer
-        rescue StandardError => e
-          warn "Unable to instantiate tracer: #{e}"
-          nil
-        end
-      end
-
-      def self.parse_connection_string(connection_string)
-        parsed = URI.parse(connection_string)
+        Tracing.configured_service_name = service_name
 
-        raise "Invalid tracing connection string" unless valid_uri?(parsed)
-
-        { driver_name: parsed.host, options: parse_query(parsed.query) }
+        tracer
+      rescue StandardError => e
+        warn "Unable to instantiate tracer: #{e}"
+        nil
       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
 
-        uri.scheme == OPENTRACING_SCHEME && uri.host.to_s =~ /^[a-z0-9_]+$/ && uri.path.empty?
+      def self.warn_opentracing_block_ignored
+        warn "Warning: Configuration block provided but ignored - " \
+          "OpenTracing connection strings don't support SDK customization. " \
+          "Use OTLP (otlp://) for OpenTelemetry SDK features."
       end
-      private_class_method :valid_uri?
+      private_class_method :warn_opentracing_block_ignored
     end
   end
 end

data/lib/labkit/tracing/grpc/client_interceptor.rb

@@ -36,7 +36,7 @@ module Labkit
           tags = { "component" => "grpc", "span.kind" => "client", "grpc.method" => method, "grpc.type" => grpc_type }
 
           TracingUtils.with_tracing(operation_name: "grpc:#{method}", tags: tags) do |span|
-            OpenTracing.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, metadata)
+            TracingUtils.tracer.inject_context(span, metadata)
 
             yield
           end

data/lib/labkit/tracing/grpc/server_interceptor.rb

@@ -42,13 +42,13 @@ module Labkit
         private
 
         def wrap_with_tracing(call, method, grpc_type)
-          context = TracingUtils.tracer.extract(OpenTracing::FORMAT_TEXT_MAP, call.metadata)
+          context = TracingUtils.tracer.extract_context(call.metadata)
           method_name = "/#{rpc_split(method).join("/")}"
           tags = {
             "component" => "grpc",
             "span.kind" => "server",
             "grpc.method" => method_name,
-            "grpc.type" => grpc_type,
+            "grpc.type" => grpc_type
           }
 
           TracingUtils.with_tracing(operation_name: "grpc:#{method_name}", child_of: context, tags: tags) do |_span|

data/lib/labkit/tracing/jaeger_factory.rb

@@ -4,14 +4,12 @@ require "active_support"
 require "active_support/core_ext"
 
 require "jaeger/client"
+require "opentracing"
 
 module Labkit
   module Tracing
     # JaegerFactory will configure Jaeger distributed tracing
     class JaegerFactory
-      # When the probabilistic sampler is used, by default 0.1% of requests will be traced
-      DEFAULT_PROBABILISTIC_RATE = 0.001
-
       # The default port for the Jaeger agent UDP listener
       DEFAULT_UDP_PORT = 6831
 
@@ -31,7 +29,7 @@ module Labkit
         kwargs = {
           service_name: service_name,
           sampler: get_sampler(options[:sampler], options[:sampler_param]),
-          reporter: get_reporter(service_name, options[:http_endpoint], options[:udp_endpoint], headers),
+          reporter: get_reporter(service_name, options[:http_endpoint], options[:udp_endpoint], headers)
         }.compact
 
         extra_params = options.except(:sampler, :sampler_param, :http_endpoint, :udp_endpoint, :strict_parsing, :debug)
@@ -43,7 +41,12 @@ module Labkit
           warn message
         end
 
-        Jaeger::Client.build(**kwargs)
+        tracer = Jaeger::Client.build(**kwargs)
+
+        # Set as global tracer for consistency with OpenTelemetry behavior
+        OpenTracing.global_tracer = tracer if tracer
+
+        tracer
       end
 
       def self.build_headers(options)
@@ -60,14 +63,14 @@ module Labkit
           headers["Authorization"] = "Basic " + Base64.strict_encode64("#{user}:#{password}")
         end
 
-        return headers
+        headers
       end
       private_class_method :build_headers
 
       def self.get_sampler(sampler_type, sampler_param)
         case sampler_type
         when "probabilistic"
-          sampler_rate = sampler_param ? sampler_param.to_f : DEFAULT_PROBABILISTIC_RATE
+          sampler_rate = sampler_param ? sampler_param.to_f : Factory::DEFAULT_PROBABILISTIC_RATE
           Jaeger::Samplers::Probabilistic.new(rate: sampler_rate)
         when "const"
           const_value = sampler_param == "1"
@@ -92,7 +95,7 @@ module Labkit
       private_class_method :get_reporter
 
       def self.get_http_sender(encoder, address, headers)
-        Jaeger::HttpSender.new(url: address, headers: headers, encoder: encoder, logger: Logger.new(STDOUT))
+        Jaeger::HttpSender.new(url: address, headers: headers, encoder: encoder, logger: Logger.new($stdout))
       end
       private_class_method :get_http_sender
 
@@ -101,7 +104,7 @@ module Labkit
         host = pair[0]
         port = pair[1] ? pair[1].to_i : DEFAULT_UDP_PORT
 
-        Jaeger::UdpSender.new(host: host, port: port, encoder: encoder, logger: Logger.new(STDOUT))
+        Jaeger::UdpSender.new(host: host, port: port, encoder: encoder, logger: Logger.new($stdout))
       end
       private_class_method :get_udp_sender
     end