gitlab-labkit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b0e98b5b882ecd840a8fd9cc638c6c6c8802249ac7a8c501b6fba56deb1170dc
+  data.tar.gz: 46c8894fc4cd432bc07a08c64f3090976fa74476d21b1bf482ead09c93cb27f8
+SHA512:
+  metadata.gz: d8c5fd9a8309b00b3c62652b62fbac2112dc023a5061d85731127c519ba6cb77c475ff405142cac74fb9d5eb30239b17c0d23978998ca8dca79f4f352b950897
+  data.tar.gz: b7fb1d3b8c683295a58054192f1326ce985714698991c7e9f304631cb3ba4b0fd92e49b282f587ad9396b7f1846e0550cd9278fa992e254dc447bb898b81d208

data/lib/labkit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Labkit
+  autoload :Correlation, 'labkit/correlation'
+  autoload :Tracing, 'labkit/tracing'
+  autoload :Logging, 'labkit/logging'
+
+  def self.process_name
+    return 'sidekiq' if Sidekiq.server?
+    return 'console' if defined?(Rails::Console)
+    return 'test' if Rails.env.test?
+
+    'web'
+  end
+end

data/lib/labkit/correlation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Correlation
+    autoload :CorrelationId, 'labkit/correlation/correlation_id'
+  end
+end

data/lib/labkit/correlation/correlation_id.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Correlation
+    module CorrelationId
+      LOG_KEY = 'correlation_id'
+
+      class << self
+        def use_id(correlation_id, &blk)
+          # always generate a id if null is passed
+          correlation_id ||= new_id
+
+          ids.push(correlation_id || new_id)
+
+          begin
+            yield(current_id)
+          ensure
+            ids.pop
+          end
+        end
+
+        def current_id
+          ids.last
+        end
+
+        def current_or_new_id
+          current_id || new_id
+        end
+
+        private
+
+        def ids
+          Thread.current[:correlation_id] ||= []
+        end
+
+        def new_id
+          SecureRandom.uuid
+        end
+      end
+    end
+  end
+end

data/lib/labkit/logging.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Logging
+    autoload :Sanitizer, 'labkit/logging/sanitizer'
+  end
+end

data/lib/labkit/logging/sanitizer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Logging
+    class Sanitizer
+      ALLOWED_SCHEMES = %w[http https ssh git].freeze
+
+      def self.sanitize_field(content)
+        regexp = URI::DEFAULT_PARSER.make_regexp(ALLOWED_SCHEMES)
+
+        content.gsub(regexp) { |url| masked_url(url) }
+      end
+
+      def self.masked_url(url)
+        url = url.to_s.strip
+        url = Addressable::URI.parse(url)
+
+        url.password = '*****' if url.password.present?
+        url.user = '*****' if url.user.present?
+        url.to_s
+      rescue Addressable::URI::InvalidURIError
+        ''
+      end
+    end
+  end
+end

data/lib/labkit/tracing.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+
+module Labkit
+  module Tracing
+    autoload :Common, 'labkit/tracing/common'
+    autoload :Factory, 'labkit/tracing/factory'
+    autoload :GRPCInterceptor, 'labkit/tracing/grpc_interceptor'
+    autoload :JaegerFactory, 'labkit/tracing/jaeger_factory'
+    autoload :RackMiddleware, 'labkit/tracing/rack_middleware'
+
+    module Rails
+      autoload :ActionViewSubscriber, 'labkit/tracing/rails/action_view_subscriber.rb'
+      autoload :ActiveRecordSubscriber, 'labkit/tracing/rails/active_record_subscriber.rb'
+      autoload :RailsCommon, 'labkit/tracing/rails/rails_common'
+    end
+
+    module Sidekiq
+      autoload :ClientMiddleware, 'labkit/tracing/sidekiq/client_middleware'
+      autoload :ServerMiddleware, 'labkit/tracing/sidekiq/server_middleware'
+      autoload :SidekiqCommon, 'labkit/tracing/sidekiq/sidekiq_common'
+    end
+
+    # Only enable tracing when the `GITLAB_TRACING` env var is configured. Note that we avoid using ApplicationSettings since
+    # the same environment variable needs to be configured for Workhorse, Gitaly and any other components which
+    # emit tracing. Since other components may start before Rails, and may not have access to ApplicationSettings,
+    # an env var makes more sense.
+    def self.enabled?
+      connection_string.present?
+    end
+
+    def self.connection_string
+      ENV['GITLAB_TRACING']
+    end
+
+    def self.tracing_url_template
+      ENV['GITLAB_TRACING_URL']
+    end
+
+    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.
+    def self.tracing_url
+      return unless tracing_url_enabled?
+
+      tracing_url_template.to_s % { correlation_id: Labkit::Correlation::CorrelationId.current_id.to_s, service: Labkit.process_name }
+    end
+  end
+end

data/lib/labkit/tracing/common.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'opentracing'
+
+module Labkit
+  module Tracing
+    module Common
+      def tracer
+        OpenTracing.global_tracer
+      end
+
+      # Convience method for running a block with a span
+      def in_tracing_span(operation_name:, tags:, child_of: nil)
+        scope = tracer.start_active_span(operation_name, child_of: child_of, tags: tags)
+        span = scope.span
+
+        # Add correlation details to the span if we have them
+        correlation_id = Labkit::Correlation::CorrelationId.current_id
+        span.set_tag('correlation_id', correlation_id) if correlation_id
+
+        begin
+          yield span
+        rescue StandardError => e
+          log_exception_on_span(span, e)
+          raise e
+        ensure
+          scope.close
+        end
+      end
+
+      def 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)
+
+        log_exception_on_span(span, exception) if exception
+
+        span.finish(end_time: end_time)
+      end
+
+      def log_exception_on_span(span, exception)
+        span.set_tag('error', true)
+        span.log_kv(kv_tags_for_exception(exception))
+      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

data/lib/labkit/tracing/factory.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Labkit
+  module Tracing
+    class Factory
+      OPENTRACING_SCHEME = 'opentracing'
+
+      def self.create_tracer(service_name, connection_string)
+        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])
+          else
+            raise "Unknown driver: #{driver_name}"
+          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)
+
+        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/grpc_interceptor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'opentracing'
+require 'grpc'
+
+module Labkit
+  module Tracing
+    class GRPCInterceptor < GRPC::ClientInterceptor
+      include Common
+      include Singleton
+
+      def request_response(request:, call:, method:, metadata:)
+        wrap_with_tracing(method, 'unary', metadata) { yield }
+      end
+
+      def client_streamer(requests:, call:, method:, metadata:)
+        wrap_with_tracing(method, 'client_stream', metadata) { yield }
+      end
+
+      def server_streamer(request:, call:, method:, metadata:)
+        wrap_with_tracing(method, 'server_stream', metadata) { yield }
+      end
+
+      def bidi_streamer(requests:, call:, method:, metadata:)
+        wrap_with_tracing(method, 'bidi_stream', metadata) { yield }
+      end
+
+      private
+
+      def wrap_with_tracing(method, grpc_type, metadata)
+        tags = { 'component' => 'grpc', 'span.kind' => 'client', 'grpc.method' => method, 'grpc.type' => grpc_type }
+
+        in_tracing_span(operation_name: "grpc:#{method}", tags: tags) do |span|
+          OpenTracing.inject(span.context, OpenTracing::FORMAT_TEXT_MAP, metadata)
+
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/jaeger_factory.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'jaeger/client'
+
+module Labkit
+  module 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
+
+      # Reduce this from default of 10 seconds as the Ruby jaeger
+      # client doesn't have overflow control, leading to very large
+      # messages which fail to send over UDP (max packet = 64k)
+      # Flush more often, with smaller packets
+      FLUSH_INTERVAL = 5
+
+      def self.create_tracer(service_name, options)
+        kwargs = {
+          service_name: service_name,
+          sampler: get_sampler(options[:sampler], options[:sampler_param]),
+          reporter: get_reporter(service_name, options[:http_endpoint], options[:udp_endpoint])
+        }
+          .compact
+
+        extra_params = options.except(:sampler, :sampler_param, :http_endpoint, :udp_endpoint, :strict_parsing, :debug)
+        if extra_params.present?
+          message = "jaeger tracer: invalid option: #{extra_params.keys.join(', ')}"
+
+          raise message if options[:strict_parsing]
+
+          warn message
+        end
+
+        Jaeger::Client.build(kwargs)
+      end
+
+      def self.get_sampler(sampler_type, sampler_param)
+        case sampler_type
+        when 'probabilistic'
+          sampler_rate = sampler_param ? sampler_param.to_f : DEFAULT_PROBABILISTIC_RATE
+          Jaeger::Samplers::Probabilistic.new(rate: sampler_rate)
+        when 'const'
+          const_value = sampler_param == '1'
+          Jaeger::Samplers::Const.new(const_value)
+        end
+      end
+      private_class_method :get_sampler
+
+      def self.get_reporter(service_name, http_endpoint, udp_endpoint)
+        encoder = Jaeger::Encoders::ThriftEncoder.new(service_name: service_name)
+
+        if http_endpoint.present?
+          sender = get_http_sender(encoder, http_endpoint)
+        elsif udp_endpoint.present?
+          sender = get_udp_sender(encoder, udp_endpoint)
+        else
+          return nil
+        end
+
+        Jaeger::Reporters::RemoteReporter.new(sender: sender, flush_interval: FLUSH_INTERVAL)
+      end
+      private_class_method :get_reporter
+
+      def self.get_http_sender(encoder, address)
+        Jaeger::HttpSender.new(url: address, encoder: encoder, logger: Logger.new(STDOUT))
+      end
+      private_class_method :get_http_sender
+
+      def self.get_udp_sender(encoder, address)
+        pair = address.split(':', 2)
+        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))
+      end
+      private_class_method :get_udp_sender
+    end
+  end
+end

data/lib/labkit/tracing/rack_middleware.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'opentracing'
+require 'rails'
+
+module Labkit
+  module Tracing
+    class RackMiddleware
+      include Common
+
+      REQUEST_METHOD = 'REQUEST_METHOD'
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        method = env[REQUEST_METHOD]
+
+        context = tracer.extract(OpenTracing::FORMAT_RACK, env)
+        tags = { 'component' => 'rack', 'span.kind' => 'server', 'http.method' => method, 'http.url' => self.class.build_sanitized_url_from_env(env) }
+
+        in_tracing_span(operation_name: "http:#{method}", child_of: context, tags: tags) do |span|
+          @app.call(env).tap { |status_code, _headers, _body| span.set_tag('http.status_code', status_code) }
+        end
+      end
+
+      # Generate a sanitized (safe) request URL from the rack environment
+      def self.build_sanitized_url_from_env(env)
+        request = ::ActionDispatch::Request.new(env)
+
+        original_url = request.original_url
+        uri = URI.parse(original_url)
+        uri.query = request.filtered_parameters.to_query if uri.query.present?
+
+        uri.to_s
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/action_view_subscriber.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      class ActionViewSubscriber
+        include RailsCommon
+
+        COMPONENT_TAG = 'ActionView'
+        RENDER_TEMPLATE_NOTIFICATION_TOPIC = 'render_template.action_view'
+        RENDER_COLLECTION_NOTIFICATION_TOPIC = 'render_collection.action_view'
+        RENDER_PARTIAL_NOTIFICATION_TOPIC = 'render_partial.action_view'
+
+        # Instruments Rails ActionView events for opentracing.
+        # Returns a lambda, which, when called will unsubscribe from the notifications
+        def self.instrument
+          subscriber = new
+
+          subscriptions = [
+            ActiveSupport::Notifications.subscribe(RENDER_TEMPLATE_NOTIFICATION_TOPIC) do |_, start, finish, _, payload|
+              subscriber.notify_render_template(start, finish, payload)
+            end,
+            ActiveSupport::Notifications.subscribe(RENDER_COLLECTION_NOTIFICATION_TOPIC) do |_, start, finish, _, payload|
+              subscriber.notify_render_collection(start, finish, payload)
+            end,
+            ActiveSupport::Notifications.subscribe(RENDER_PARTIAL_NOTIFICATION_TOPIC) do |_, start, finish, _, payload|
+              subscriber.notify_render_partial(start, finish, payload)
+            end
+          ]
+
+          create_unsubscriber subscriptions
+        end
+
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        def notify_render_template(start, finish, payload)
+          generate_span_for_notification('render_template', start, finish, payload, tags_for_render_template(payload))
+        end
+
+        def notify_render_collection(start, finish, payload)
+          generate_span_for_notification('render_collection', start, finish, payload, tags_for_render_collection(payload))
+        end
+
+        def notify_render_partial(start, finish, payload)
+          generate_span_for_notification('render_partial', start, finish, payload, tags_for_render_partial(payload))
+        end
+
+        private
+
+        def tags_for_render_template(payload)
+          { 'component' => COMPONENT_TAG, 'template.id' => payload[:identifier], 'template.layout' => payload[:layout] }
+        end
+
+        def tags_for_render_collection(payload)
+          {
+            'component' => COMPONENT_TAG,
+            'template.id' => payload[:identifier],
+            'template.count' => payload[:count] || 0,
+            'template.cache.hits' => payload[:cache_hits] || 0
+          }
+        end
+
+        def tags_for_render_partial(payload)
+          { 'component' => COMPONENT_TAG, 'template.id' => payload[:identifier] }
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/active_record_subscriber.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      class ActiveRecordSubscriber
+        include RailsCommon
+
+        ACTIVE_RECORD_NOTIFICATION_TOPIC = 'sql.active_record'
+        OPERATION_NAME_PREFIX = 'active_record:'
+        DEFAULT_OPERATION_NAME = 'sqlquery'
+
+        # Instruments Rails ActiveRecord events for opentracing.
+        # Returns a lambda, which, when called will unsubscribe from the notifications
+        def self.instrument
+          subscriber = new
+
+          subscription =
+            ActiveSupport::Notifications.subscribe(ACTIVE_RECORD_NOTIFICATION_TOPIC) do |_, start, finish, _, payload|
+              subscriber.notify(start, finish, payload)
+            end
+
+          create_unsubscriber [subscription]
+        end
+
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        def notify(start, finish, payload)
+          generate_span_for_notification(notification_name(payload), start, finish, payload, tags_for_notification(payload))
+        end
+
+        private
+
+        def notification_name(payload)
+          OPERATION_NAME_PREFIX + (payload[:name].presence || DEFAULT_OPERATION_NAME)
+        end
+
+        def tags_for_notification(payload)
+          {
+            'component' => 'ActiveRecord',
+            'span.kind' => 'client',
+            'db.type' => 'sql',
+            'db.connection_id' => payload[:connection_id],
+            'db.cached' => payload[:cached] || false,
+            'db.statement' => payload[:sql]
+          }
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/rails_common.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+
+module Labkit
+  module Tracing
+    module Rails
+      module RailsCommon
+        extend ActiveSupport::Concern
+        include Labkit::Tracing::Common
+
+        class_methods do
+          def create_unsubscriber(subscriptions)
+            -> { subscriptions.each { |subscriber| ActiveSupport::Notifications.unsubscribe(subscriber) } }
+          end
+        end
+
+        def generate_span_for_notification(operation_name, start, finish, payload, tags)
+          exception = payload[:exception]
+
+          postnotify_span(operation_name, start, finish, tags: tags, exception: exception)
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/sidekiq/client_middleware.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'opentracing'
+
+module Labkit
+  module Tracing
+    module Sidekiq
+      class ClientMiddleware
+        include SidekiqCommon
+
+        SPAN_KIND = 'client'
+
+        def call(worker_class, job, queue, redis_pool)
+          in_tracing_span(operation_name: "sidekiq:#{job['class']}", tags: tags_from_job(job, SPAN_KIND)) do |span|
+            # Inject the details directly into the job
+            tracer
+              .inject(span.context, OpenTracing::FORMAT_TEXT_MAP, job)
+
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/sidekiq/server_middleware.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'opentracing'
+
+module Labkit
+  module Tracing
+    module Sidekiq
+      class ServerMiddleware
+        include SidekiqCommon
+
+        SPAN_KIND = 'server'
+
+        def call(worker, job, queue)
+          context = tracer.extract(OpenTracing::FORMAT_TEXT_MAP, job)
+
+          in_tracing_span(operation_name: "sidekiq:#{job['class']}", child_of: context, tags: tags_from_job(job, SPAN_KIND)) { |span| yield }
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/sidekiq/sidekiq_common.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Sidekiq
+      module SidekiqCommon
+        include Labkit::Tracing::Common
+
+        def tags_from_job(job, kind)
+          {
+            'component' => 'sidekiq',
+            'span.kind' => kind,
+            'sidekiq.queue' => job['queue'],
+            'sidekiq.jid' => job['jid'],
+            'sidekiq.retry' => job['retry'].to_s,
+            'sidekiq.args' => job['args']&.join(', ')
+          }
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,229 @@
+--- !ruby/object:Gem::Specification
+name: gitlab-labkit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Newdigate
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-02-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: grpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: jaeger-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: opentracing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: gitlab-styles
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.6.0
+- !ruby/object:Gem::Dependency
+  name: rspec-parameterized
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.54.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.22.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.22.1
+description: 
+email:
+- andrew@gitlab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/labkit.rb
+- lib/labkit/correlation.rb
+- lib/labkit/correlation/correlation_id.rb
+- lib/labkit/logging.rb
+- lib/labkit/logging/sanitizer.rb
+- lib/labkit/tracing.rb
+- lib/labkit/tracing/common.rb
+- lib/labkit/tracing/factory.rb
+- lib/labkit/tracing/grpc_interceptor.rb
+- lib/labkit/tracing/jaeger_factory.rb
+- lib/labkit/tracing/rack_middleware.rb
+- lib/labkit/tracing/rails/action_view_subscriber.rb
+- lib/labkit/tracing/rails/active_record_subscriber.rb
+- lib/labkit/tracing/rails/rails_common.rb
+- lib/labkit/tracing/sidekiq/client_middleware.rb
+- lib/labkit/tracing/sidekiq/server_middleware.rb
+- lib/labkit/tracing/sidekiq/sidekiq_common.rb
+homepage: http://about.gitlab.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Instrumentation for GitLab
+test_files: []