gitlab-labkit 1.4.0 → 1.5.0

data/lib/labkit/tracing/open_telemetry_factory.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "base64"
+require "cgi"
+require "active_support"
+require "active_support/core_ext"
+
+require "opentelemetry/sdk"
+require "opentelemetry/exporter/otlp"
+
+module Labkit
+  module Tracing
+    # OpenTelemetryFactory will configure OpenTelemetry distributed tracing
+    class OpenTelemetryFactory
+      OTLP_SCHEME = "otlp"
+
+      # The default endpoint for OTLP HTTP exporter
+      DEFAULT_HTTP_ENDPOINT = "http://localhost:4318/v1/traces"
+
+      class << self
+        # @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
+        # @yieldparam config [OpenTelemetry::SDK::Configurator] The SDK configurator
+        # @return [Tracer, nil] The configured tracer or nil if initialization fails
+        def create_tracer(service_name, connection_string, &)
+          return unless connection_string.present?
+
+          options = parse_otlp_connection_string(connection_string)
+          # The service_name parameter from GITLAB_TRACING takes precedence over the application one
+          service_name = options[:service_name] if options[:service_name]
+
+          # parse exporter headers as necessary
+          headers = build_headers(options)
+
+          # Get sampler and exporter from GITLAB_TRACING
+          sampler = get_sampler(options[:sampler], options[:sampler_param])
+          exporter = get_exporter(options[:http_endpoint], options[:udp_endpoint], headers)
+
+          # Build base resource
+          base_resource = OpenTelemetry::SDK::Resources::Resource.create(
+            OpenTelemetry::SemanticConventions::Resource::SERVICE_NAME => service_name
+          )
+
+          configure(service_name, base_resource, sampler, exporter, &)
+
+          extra_params = options.except(
+            :sampler,
+            :sampler_param,
+            :http_endpoint,
+            :udp_endpoint,
+            :strict_parsing,
+            :debug,
+            :service_name
+          )
+
+          if extra_params.present?
+            message = "opentelemetry tracer: invalid option: #{extra_params.keys.join(', ')}"
+
+            raise message if options[:strict_parsing]
+
+            warn message
+          end
+
+          OpenTelemetry.tracer_provider.tracer(service_name)
+        end
+
+        private
+
+        def configure(service_name, base_resource, sampler, exporter)
+          if block_given?
+            OpenTelemetry::SDK.configure do |c|
+              c.service_name = service_name
+              c.resource = base_resource
+
+              processor = create_span_processor(exporter)
+              c.add_span_processor(processor) if processor
+
+              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)
+          else
+            create_and_configure_provider(base_resource, sampler, exporter)
+          end
+        end
+
+        def create_span_processor(exporter)
+          return nil unless exporter
+
+          if exporter.is_a?(OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter)
+            OpenTelemetry::SDK::Trace::Export::SimpleSpanProcessor.new(exporter)
+          else
+            OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(exporter)
+          end
+        end
+
+        def create_and_configure_provider(resource, sampler, exporter)
+          tracer_provider = OpenTelemetry::SDK::Trace::TracerProvider.new(
+            resource: resource,
+            sampler: sampler
+          )
+
+          processor = create_span_processor(exporter)
+          tracer_provider.add_span_processor(processor) if processor
+
+          OpenTelemetry.tracer_provider = tracer_provider
+        end
+
+        def build_headers(options)
+          return {} unless options&.key?(:http_endpoint)
+
+          endpoint = options[:http_endpoint]
+          return {} unless endpoint
+
+          parsed = URI.parse(endpoint)
+
+          headers = {}
+          user = parsed.user
+          password = parsed.password
+          if user.present? && password.present?
+            credentials = Base64.strict_encode64("#{CGI.unescape(user)}:#{CGI.unescape(password)}")
+            headers["Authorization"] = "Basic #{credentials}"
+          end
+
+          headers
+        end
+
+        def get_sampler(sampler_type, sampler_param)
+          case sampler_type
+          when "probabilistic"
+            sampler_rate = sampler_param ? sampler_param.to_f : Factory::DEFAULT_PROBABILISTIC_RATE
+            OpenTelemetry::SDK::Trace::Samplers::TraceIdRatioBased.new(sampler_rate)
+          when "const"
+            if sampler_param == "1"
+              OpenTelemetry::SDK::Trace::Samplers::ALWAYS_ON
+            else
+              OpenTelemetry::SDK::Trace::Samplers::ALWAYS_OFF
+            end
+          else
+            OpenTelemetry::SDK::Trace::Samplers::TraceIdRatioBased.new(Factory::DEFAULT_PROBABILISTIC_RATE)
+          end
+        end
+
+        def get_exporter(http_endpoint, udp_endpoint, headers)
+          # OpenTelemetry doesn't support UDP, warn if specified
+          # https://github.com/open-telemetry/opentelemetry-collector/discussions/6016
+          warn "opentelemetry tracer: UDP endpoint not supported, ignoring udp_endpoint option" if udp_endpoint.present?
+
+          # Check for console exporter (for development/testing)
+          return get_console_exporter if http_endpoint&.include?("://console")
+
+          get_http_exporter(http_endpoint, headers) if http_endpoint.present?
+        end
+
+        def get_http_exporter(endpoint, headers)
+          OpenTelemetry::Exporter::OTLP::Exporter.new(
+            endpoint: endpoint,
+            headers: headers
+          )
+        end
+
+        def get_console_exporter
+          OpenTelemetry::SDK::Trace::Export::ConsoleSpanExporter.new
+        end
+
+        def parse_otlp_connection_string(connection_string)
+          parsed = URI.parse(connection_string)
+
+          # Parse query parameters for additional options
+          options = parse_query(parsed.query)
+
+          # Handle console exporter (special case - no endpoint needed)
+          if parsed.host == "console"
+            options[:http_endpoint] = "http://console"
+            return options
+          end
+
+          endpoint = build_otlp_endpoint(parsed)
+          options[:http_endpoint] = endpoint
+
+          options
+        end
+
+        def build_otlp_endpoint(uri)
+          # Reconstruct the endpoint URL with scheme, host, port, and path
+          scheme = uri.scheme == OTLP_SCHEME ? "http" : uri.scheme
+          host = uri.host
+          port = uri.port
+          path = uri.path.empty? ? "" : uri.path
+
+          # Include userinfo (username:password) if present
+          userinfo = uri.userinfo ? "#{uri.userinfo}@" : ""
+
+          # Build the endpoint
+          endpoint = "#{scheme}://#{userinfo}#{host}"
+          endpoint += ":#{port}" if port
+          endpoint += path
+
+          endpoint
+        end
+
+        def parse_query(query)
+          return {} unless query
+
+          CGI.parse(query).symbolize_keys.transform_values(&:first)
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/open_tracing_factory.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Labkit
+  module Tracing
+    class OpenTracingFactory
+      OPENTRACING_SCHEME = "opentracing"
+
+      def self.create_tracer(service_name, connection_string)
+        return unless connection_string.present?
+
+        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])
+        else
+          raise "Unknown driver: #{driver_name}"
+        end
+      end
+
+      def self.parse_connection_string(connection_string)
+        parsed = URI.parse(connection_string)
+
+        raise "Invalid tracing connection string" unless valid_uri?(parsed)
+
+        { driver_name: parsed.host, options: parse_query(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
+
+        uri.scheme == OPENTRACING_SCHEME && uri.host.to_s =~ /^[a-z0-9_]+$/ && uri.path.empty?
+      end
+      private_class_method :valid_uri?
+    end
+  end
+end

data/lib/labkit/tracing/rack_middleware.rb

@@ -18,7 +18,7 @@ module Labkit
       def call(env)
         method = env[REQUEST_METHOD]
 
-        context = TracingUtils.tracer.extract(OpenTracing::FORMAT_RACK, env)
+        context = TracingUtils.tracer.extract_context(env, format: OpenTracing::FORMAT_RACK)
         tags = { "component" => "rack", "span.kind" => "server", "http.method" => method, "http.url" => self.class.build_sanitized_url_from_env(env) }
 
         TracingUtils.with_tracing(operation_name: "http:#{method}", child_of: context, tags: tags) do |span|

data/lib/labkit/tracing/railtie.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    class Railtie < ::Rails::Railtie
+      initializer "labkit.tracing.insert_middleware", after: :load_config_initializers do |app|
+        next unless Labkit::Tracing.enabled?
+
+        # Insert after Labkit::Middleware::Rack for proper correlation ID propagation.
+        app.middleware.insert_after Labkit::Middleware::Rack, Labkit::Tracing::RackMiddleware
+        ::Rails.logger.info "Labkit::Tracing::RackMiddleware automatically inserted after Labkit::Middleware::Rack"
+      end
+    end
+  end
+end

data/lib/labkit/tracing/tracing_utils.rb

@@ -10,64 +10,67 @@ module Labkit
     class TracingUtils
       # Convience method for running a block with a span
       def self.with_tracing(operation_name:, tags:, child_of: nil)
-        scope = tracer.start_active_span(operation_name, child_of: child_of, tags: tags)
-        span = scope.span
+        tracer.in_span(operation_name, child_of: child_of, tags: tags) do |span|
+          log_common_fields_on_span(span, operation_name)
 
-        log_common_fields_on_span(span, operation_name)
-
-        begin
-          yield span
-        rescue StandardError => e
-          log_exception_on_span(span, e)
-          raise e
-        ensure
-          scope.close
+          begin
+            yield span
+          rescue StandardError => e
+            log_exception_on_span(span, e)
+            raise e
+          end
         end
       end
 
       # Obtain a tracer instance
+      #
+      # Returns the appropriate tracer based on connection string configuration:
+      # - OpenTelemetry (OTLP): When GITLAB_TRACING uses otlp:// scheme
+      # - OpenTracing: When GITLAB_TRACING uses opentracing:// scheme or not set
+      #
+      # For OpenTelemetry, the tracer's instrumentation scope name is determined by:
+      # - The service_name passed to Factory.create_tracer
+      # - Falls back to DEFAULT_SERVICE_NAME if Factory was not used
+      #
+      # Both OpenTelemetry and OpenTracing provide no-op tracers by default:
+      # - OpenTelemetry: Uses ProxyTracerProvider until SDK is configured
+      # - OpenTracing: Uses default no-op global_tracer
+      #
+      # This allows spans to be created but not exported when tracing is not initialized,
+      # letting the application run safely while producing no trace data.
       def self.tracer
-        OpenTracing.global_tracer
+        @tracer ||=
+          if Tracing.otlp_connection?
+            require "opentelemetry/sdk"
+
+            otel_tracer = OpenTelemetry.tracer_provider.tracer(Tracing.configured_service_name)
+            Adapters::OpentelemetryTracer.new(otel_tracer)
+          else
+            Adapters::OpentracingTracer.new(OpenTracing.global_tracer)
+          end
       end
 
       # Generate a span retrospectively
       def self.postnotify_span(operation_name, start_time, end_time, tags: nil, child_of: nil, exception: nil)
-        span = OpenTracing.start_span(operation_name, start_time: start_time, tags: tags, child_of: child_of)
+        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.finish(end_time: end_time)
+        span.finish(end_timestamp: end_time)
       end
 
       # Add common fields to a span
       def self.log_common_fields_on_span(span, operation_name)
         correlation_id = Labkit::Correlation::CorrelationId.current_id
+
         span.set_tag("correlation_id", correlation_id) if correlation_id
-        span.log_kv(stack: caller.join('\n')) if include_stacktrace?(operation_name)
+        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)
-        return if exception.blank?
-
-        span.set_tag("error", true)
-        span.log_kv(**kv_tags_for_exception(exception))
-      end
-
-      # Generate key-value tags for an exception
-      def self.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
+        span.set_error(exception)
       end
 
       def self.include_stacktrace?(operation_name)

data/lib/labkit/tracing.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/module/attribute_accessors"
+
 module Labkit
   # Tracing provides distributed tracing functionality
   module Tracing
     autoload :AbstractInstrumenter, "labkit/tracing/abstract_instrumenter"
+    autoload :AutoInitialize, "labkit/tracing/auto_initialize"
     autoload :TracingCommon, "labkit/tracing/tracing_common"
     autoload :Factory, "labkit/tracing/factory"
     autoload :GRPC, "labkit/tracing/grpc"
     autoload :GRPCInterceptor, "labkit/tracing/grpc_interceptor" # Deprecated
     autoload :JaegerFactory, "labkit/tracing/jaeger_factory"
+    autoload :OpenTelemetryFactory, "labkit/tracing/open_telemetry_factory"
+    autoload :OpenTracingFactory, "labkit/tracing/open_tracing_factory"
     autoload :RackMiddleware, "labkit/tracing/rack_middleware"
     autoload :Rails, "labkit/tracing/rails"
     autoload :Redis, "labkit/tracing/redis"
@@ -16,6 +21,21 @@ module Labkit
     autoload :Sidekiq, "labkit/tracing/sidekiq"
     autoload :TracingUtils, "labkit/tracing/tracing_utils"
 
+    module Adapters
+      autoload :BaseSpan, "labkit/tracing/adapters/base_span"
+      autoload :OpentelemetrySpan, "labkit/tracing/adapters/opentelemetry_span"
+      autoload :OpentracingSpan, "labkit/tracing/adapters/opentracing_span"
+      autoload :BaseTracer, "labkit/tracing/adapters/base_tracer"
+      autoload :OpentelemetryTracer, "labkit/tracing/adapters/opentelemetry_tracer"
+      autoload :OpentracingTracer, "labkit/tracing/adapters/opentracing_tracer"
+    end
+
+    DEFAULT_SERVICE_NAME = :'labkit-service'
+
+    # Module-level attribute for storing the configured service name
+    # Set by Factory.create_tracer when a tracer is created
+    mattr_accessor :configured_service_name, default: DEFAULT_SERVICE_NAME
+
     # Tracing is only enabled when the `GITLAB_TRACING` env var is configured.
     def self.enabled?
       connection_string.present?
@@ -25,13 +45,28 @@ module Labkit
       ENV["GITLAB_TRACING"]
     end
 
+    def self.otlp_connection?(connection_string = ENV["GITLAB_TRACING"])
+      connection_string.to_s.start_with?("#{OpenTelemetryFactory::OTLP_SCHEME}://")
+    end
+
+    def self.opentracing_connection?(connection_string = ENV["GITLAB_TRACING"])
+      connection_string.to_s.start_with?("#{OpenTracingFactory::OPENTRACING_SCHEME}://")
+    end
+
+    # Returns the tracing URL template from the GITLAB_TRACING_URL environment variable.
+    #
+    # @note This method is only useful with OpenTracing and Jaeger. It does not work with
+    #   OpenTelemetry backends, as they expect trace_id (W3C standard) rather than
+    #   correlation_id (GitLab-specific) for trace lookups.
+    #
+    # @return [String, nil] The URL template with placeholders for {{ correlation_id }} and {{ service }}
     def self.tracing_url_template
       ENV["GITLAB_TRACING_URL"]
     end
 
     # Check if the current request is being traced.
     def self.sampled?
-      context = OpenTracing.active_span&.context
+      context = TracingUtils.tracer.active_span&.context
       context&.respond_to?(:sampled?) && context&.sampled?
     end
 
@@ -39,12 +74,36 @@ module Labkit
       @stacktrace_operations ||= Set.new(ENV["GITLAB_TRACING_INCLUDE_STACKTRACE"].to_s.split(",").map(&:strip))
     end
 
+    # Checks if tracing URL generation is enabled.
+    #
+    # @note This method is only useful with OpenTracing and Jaeger. It does not work with
+    #   OpenTelemetry backends, as they expect trace_id (W3C standard) rather than
+    #   correlation_id (GitLab-specific) for trace lookups.
+    #
+    # @return [Boolean] true if both tracing and URL template are configured
+    # @see tracing_url
     def self.tracing_url_enabled?
       enabled? && tracing_url_template.present?
     end
 
-    # This will provide a link into the distributed tracing for the current trace,
-    # if it has been captured.
+    # Generates a URL to view the current trace in a tracing UI.
+    #
+    # This method substitutes {{ correlation_id }} and {{ service }} placeholders in the
+    # GITLAB_TRACING_URL template with the current correlation ID and provided service name.
+    #
+    # @note This method is only useful with OpenTracing and Jaeger. It does not work with
+    #   OpenTelemetry backends because:
+    #   - Uses correlation_id (GitLab-specific request ID) instead of trace_id (W3C standard)
+    #   - Modern tracing UIs (Jaeger with OTLP, Grafana Tempo, etc.) expect trace_id for lookups
+    #   - Only Jaeger's legacy OpenTracing integration supports correlation_id-based URLs
+    #
+    # @param service_name [String] The name of the service to include in the URL
+    # @return [String, nil] The generated URL, or nil if tracing URL is not enabled
+    #
+    # @example With OpenTracing/Jaeger (supported)
+    #   ENV["GITLAB_TRACING_URL"] = "https://jaeger.example.com/trace?correlationId={{ correlation_id }}"
+    #   Labkit::Tracing.tracing_url("my-service")
+    #   # => "https://jaeger.example.com/trace?correlationId=abc123"
     def self.tracing_url(service_name)
       return unless tracing_url_enabled?
 
@@ -53,8 +112,50 @@ module Labkit
       # Avoid using `format` since it can throw TypeErrors
       # which we want to avoid on unsanitised env var input
       tracing_url_template.to_s
-                          .gsub("{{ correlation_id }}", correlation_id)
-                          .gsub("{{ service }}", service_name)
+        .gsub("{{ correlation_id }}", correlation_id)
+        .gsub("{{ service }}", service_name)
+    end
+
+    # Returns the underlying tracer implementation from the tracing library in use.
+    # This provides direct access to the native tracer API when LabKit's abstraction
+    # is insufficient for advanced use cases.
+    #
+    # @example Using OpenTelemetry-specific APIs
+    #   tracer = Labkit::Tracing.tracer
+    #   tracer.in_span("custom-span") do |span|
+    #     span.add_event("custom-event", attributes: { "key" => "value" })
+    #   end
+    #
+    # @return [Object] The tracer implementation:
+    #   - OpenTelemetry::SDK::Trace::Tracer when using OTLP connection
+    #   - No-op tracer when tracing is not configured
+    def self.tracer
+      TracingUtils.tracer.tracer
+    end
+
+    # Returns the currently active span from OpenTelemetry.
+    # This provides direct access to the OpenTelemetry span API.
+    #
+    # @example Adding attributes to the current span
+    #   span = Labkit::Tracing.current_span
+    #   span.set_attribute("user.id", user.id) if span.recording?
+    #
+    # @example Adding events
+    #   span = Labkit::Tracing.current_span
+    #   span.add_event("cache_miss", attributes: { "key" => cache_key })
+    #
+    # @example Conditional expensive operations
+    #   span = Labkit::Tracing.current_span
+    #   if span.recording?
+    #     span.set_attribute("expensive_data", compute_expensive_data)
+    #   end
+    #
+    # @return [OpenTelemetry::Trace::Span, nil] The current span (may be a no-op span when tracing is disabled, or nil when using OpenTracing)
+    def self.current_span
+      return nil if opentracing_connection?
+
+      require "opentelemetry/sdk"
+      OpenTelemetry::Trace.current_span
     end
 
     # This will run a block with a span
@@ -68,3 +169,5 @@ module Labkit
     end
   end
 end
+
+require "labkit/tracing/railtie" if defined?(Rails::Railtie)

data/lib/labkit/user_experience_sli/null.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "singleton"
+
 module Labkit
   module UserExperienceSli
     # Fakes Labkit::UserExperienceSli::Experience.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-labkit
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Andrew Newdigate
@@ -131,6 +131,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.3.2
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.89.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.89.1
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.31.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.31.1
 - !ruby/object:Gem::Dependency
   name: opentracing
   requirement: !ruby/object:Gem::Requirement
@@ -359,6 +401,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 8.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 8.1.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -540,7 +602,15 @@ files:
 - lib/labkit/rspec/matchers/user_experience_matchers.rb
 - lib/labkit/system.rb
 - lib/labkit/tracing.rb
+- lib/labkit/tracing/README.md
 - lib/labkit/tracing/abstract_instrumenter.rb
+- lib/labkit/tracing/adapters/base_span.rb
+- lib/labkit/tracing/adapters/base_tracer.rb
+- lib/labkit/tracing/adapters/opentelemetry_span.rb
+- lib/labkit/tracing/adapters/opentelemetry_tracer.rb
+- lib/labkit/tracing/adapters/opentracing_span.rb
+- lib/labkit/tracing/adapters/opentracing_tracer.rb
+- lib/labkit/tracing/auto_initialize.rb
 - lib/labkit/tracing/external_http.rb
 - lib/labkit/tracing/external_http/request_instrumenter.rb
 - lib/labkit/tracing/factory.rb
@@ -549,6 +619,8 @@ files:
 - lib/labkit/tracing/grpc/server_interceptor.rb
 - lib/labkit/tracing/grpc_interceptor.rb
 - lib/labkit/tracing/jaeger_factory.rb
+- lib/labkit/tracing/open_telemetry_factory.rb
+- lib/labkit/tracing/open_tracing_factory.rb
 - lib/labkit/tracing/rack_middleware.rb
 - lib/labkit/tracing/rails.rb
 - lib/labkit/tracing/rails/action_view.rb
@@ -566,6 +638,7 @@ files:
 - lib/labkit/tracing/rails/active_support/cache_read_instrumenter.rb
 - lib/labkit/tracing/rails/active_support/cache_write_instrumenter.rb
 - lib/labkit/tracing/rails/active_support/subscriber.rb
+- lib/labkit/tracing/railtie.rb
 - lib/labkit/tracing/redis.rb
 - lib/labkit/tracing/redis/redis_interceptor.rb
 - lib/labkit/tracing/redis/redis_interceptor_helper.rb