gitlab-labkit 0.10.0 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 198c31e6a0717be721e68fb8e68e145e24f66ae17338eccc80c0c4e94f638be6
-  data.tar.gz: e6ee6cf53603f78442d96b89bf8edf2720ee334d9441042dd9167fa9328a4406
+  metadata.gz: f4aea03a17735936eac617c462fb55b220f639d99d13c029de0c15dc7ace629e
+  data.tar.gz: fbf9048f2750ce87927864deb37b82d69652b27695aff4876745f509b9d4d4de
 SHA512:
-  metadata.gz: 00544f82819064032c9bd3105ed265c56e078e9204702b9b91ed28f4ba760ae4481f1b766b9c0832a9648efa8c55212ef641d008d82912bb0dfab1ca8a9d2868
-  data.tar.gz: 0b195fec25f24758afb2df4d17dc639388e537258f08182bcc3a5162253b8efab493578e11a99d2bf86370ecd476ea467cce49ffeafe372e5be3def4f15141b3
+  metadata.gz: 994ef11d2b1911eba33581b62136d4cc67b112491280710f31ea50ac04a6fb0037aa820ff3315c3146827acd6b017e10c3d6d1817d4a7aabd587c4567bcb2504
+  data.tar.gz: c522466510fad218e8ecb0376da5fe0478124f3a2adebfccedda7727b76cfa3d753f10ccb39ca94242746a0feee5d357cfd1ea2078b9b3ca9b823e688887e7dd

data/lib/labkit/context.rb

@@ -21,7 +21,8 @@ module Labkit
     LOG_KEY = "meta"
     CORRELATION_ID_KEY = "correlation_id"
     RAW_KEYS = [CORRELATION_ID_KEY].freeze
-    KNOWN_KEYS = %w[user project root_namespace subscription_plan caller_id].freeze
+    KNOWN_KEYS = %w[user project root_namespace subscription_plan caller_id
+                    related_class feature_category].freeze
 
     class << self
       def with_context(attributes = {})

data/lib/labkit/tracing.rb

@@ -28,6 +28,10 @@ module Labkit
       ENV["GITLAB_TRACING_URL"]
     end
 
+    def self.stacktrace_operations
+      @stacktrace_operations ||= Set.new(ENV["GITLAB_TRACING_INCLUDE_STACKTRACE"].to_s.split(",").map(&:strip))
+    end
+
     def self.tracing_url_enabled?
       enabled? && tracing_url_template.present?
     end

data/lib/labkit/tracing/rails.rb

@@ -4,10 +4,15 @@ module Labkit
   module Tracing
     # Rails provides classes for instrumenting Rails events
     module Rails
-      autoload :ActionViewSubscriber, "labkit/tracing/rails/action_view_subscriber"
-      autoload :ActiveRecordSubscriber, "labkit/tracing/rails/active_record_subscriber"
-      autoload :ActiveSupportSubscriber, "labkit/tracing/rails/active_support_subscriber"
+      autoload :AbstractInstrumenter, "labkit/tracing/rails/abstract_instrumenter"
+      autoload :ActionView, "labkit/tracing/rails/action_view"
+      autoload :ActiveRecord, "labkit/tracing/rails/active_record"
+      autoload :ActiveSupport, "labkit/tracing/rails/active_support"
       autoload :RailsCommon, "labkit/tracing/rails/rails_common"
+
+      ActionViewSubscriber = ActionView::Subscriber
+      ActiveRecordSubscriber = ActiveRecord::Subscriber
+      ActiveSupportSubscriber = ActiveSupport::Subscriber
     end
   end
 end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "active_support/all"
+
+module Labkit
+  module Tracing
+    module Rails
+      # 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_stack.push scope
+        end
+
+        def finish(name, id, payload)
+          scope = scope_stack.pop
+          span = scope.span
+
+          Labkit::Tracing::TracingUtils.log_common_fields_on_span(span, span_name(payload))
+
+          exception = payload[:exception]
+          Labkit::Tracing::TracingUtils.log_exception_on_span(span, exception) if exception
+
+          tags(payload).each do |k, v|
+            span.set_tag(k, v)
+          end
+
+          scope.close
+        end
+
+        def scope_stack
+          Thread.current[:_labkit_trace_scope_stack] ||= []
+        end
+
+        def span_name(payload)
+          raise "span_name not implemented"
+        end
+
+        def tags(payload)
+          {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActionView
+        autoload :RenderCollectionInstrumenter, "labkit/tracing/rails/action_view/render_collection_instrumenter"
+        autoload :RenderPartialInstrumenter, "labkit/tracing/rails/action_view/render_partial_instrumenter"
+        autoload :RenderTemplateInstrumenter, "labkit/tracing/rails/action_view/render_template_instrumenter"
+        autoload :Subscriber, "labkit/tracing/rails/action_view/subscriber"
+
+        COMPONENT_TAG = "ActionView"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActionView
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class RenderCollectionInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "render_collection"
+          end
+
+          def tags(payload)
+            {
+              "component" => COMPONENT_TAG,
+              "template.id" => payload[:identifier],
+              "template.count" => payload[:count] || 0,
+              "template.cache.hits" => payload[:cache_hits] || 0,
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActionView
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class RenderPartialInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "render_partial"
+          end
+
+          def tags(payload)
+            { "component" => COMPONENT_TAG, "template.id" => payload[:identifier] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActionView
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class RenderTemplateInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "render_template"
+          end
+
+          def tags(payload)
+            { "component" => COMPONENT_TAG, "template.id" => payload[:identifier], "template.layout" => payload[:layout] }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActionView
+        # ActionView bridges action view notifications to
+        # the distributed tracing subsystem
+        class Subscriber
+          include RailsCommon
+
+          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
+            subscriptions = [
+              ::ActiveSupport::Notifications.subscribe(RENDER_TEMPLATE_NOTIFICATION_TOPIC, RenderTemplateInstrumenter.new),
+              ::ActiveSupport::Notifications.subscribe(RENDER_COLLECTION_NOTIFICATION_TOPIC, RenderCollectionInstrumenter.new),
+              ::ActiveSupport::Notifications.subscribe(RENDER_PARTIAL_NOTIFICATION_TOPIC, RenderPartialInstrumenter.new),
+            ]
+
+            create_unsubscriber subscriptions
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveRecord
+        autoload :SqlInstrumenter, "labkit/tracing/rails/active_record/sql_instrumenter"
+        autoload :Subscriber, "labkit/tracing/rails/active_record/subscriber"
+
+        COMPONENT_TAG = "ActiveRecord"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveRecord
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class SqlInstrumenter < AbstractInstrumenter
+          OPERATION_NAME_PREFIX = "active_record:"
+          DEFAULT_OPERATION_NAME = "sqlquery"
+
+          def span_name(payload)
+            OPERATION_NAME_PREFIX + (payload[:name].presence || DEFAULT_OPERATION_NAME)
+          end
+
+          def tags(payload)
+            {
+              "component" => COMPONENT_TAG,
+              "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
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveRecord
+        # ActiveRecord bridges active record notifications to
+        # the distributed tracing subsystem
+        class Subscriber
+          include RailsCommon
+
+          ACTIVE_RECORD_NOTIFICATION_TOPIC = "sql.active_record"
+
+          # Instruments Rails ActiveRecord events for opentracing.
+          # Returns a lambda, which, when called will unsubscribe from the notifications
+          def self.instrument
+            subscription = ::ActiveSupport::Notifications.subscribe(ACTIVE_RECORD_NOTIFICATION_TOPIC, SqlInstrumenter.new)
+
+            create_unsubscriber [subscription]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveSupport
+        autoload :CacheDeleteInstrumenter, "labkit/tracing/rails/active_support/cache_delete_instrumenter"
+        autoload :CacheFetchHitInstrumenter, "labkit/tracing/rails/active_support/cache_fetch_hit_instrumenter"
+        autoload :CacheGenerateInstrumenter, "labkit/tracing/rails/active_support/cache_generate_instrumenter"
+        autoload :CacheReadInstrumenter, "labkit/tracing/rails/active_support/cache_read_instrumenter"
+        autoload :CacheWriteInstrumenter, "labkit/tracing/rails/active_support/cache_write_instrumenter"
+        autoload :Subscriber, "labkit/tracing/rails/active_support/subscriber"
+
+        COMPONENT_TAG = "ActiveSupport"
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/active_support/cache_delete_instrumenter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveSupport
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class CacheDeleteInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "cache_delete"
+          end
+
+          def tags(payload)
+            { "component" => COMPONENT_TAG, "cache.key" => payload[:key] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/active_support/cache_fetch_hit_instrumenter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveSupport
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class CacheFetchHitInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "cache_fetch_hit"
+          end
+
+          def tags(payload)
+            { "component" => COMPONENT_TAG, "cache.key" => payload[:key] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/active_support/cache_generate_instrumenter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveSupport
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class CacheGenerateInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "cache_generate"
+          end
+
+          def tags(payload)
+            { "component" => COMPONENT_TAG, "cache.key" => payload[:key] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/active_support/cache_read_instrumenter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveSupport
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class CacheReadInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "cache_read"
+          end
+
+          def tags(payload)
+            {
+              "component" => COMPONENT_TAG,
+              "cache.key" => payload[:key],
+              "cache.hit" => payload[:hit],
+              "cache.super_operation" => payload[:super_operation],
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/active_support/cache_write_instrumenter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveSupport
+        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html
+        class CacheWriteInstrumenter < AbstractInstrumenter
+          def span_name(payload)
+            "cache_write"
+          end
+
+          def tags(payload)
+            { "component" => COMPONENT_TAG, "cache.key" => payload[:key] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/labkit/tracing/rails/active_support/subscriber.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Labkit
+  module Tracing
+    module Rails
+      module ActiveSupport
+        # ActiveSupport bridges action active support notifications to
+        # the distributed tracing subsystem
+        class Subscriber
+          include RailsCommon
+
+          CACHE_READ_TOPIC = "cache_read.active_support"
+          CACHE_GENERATE_TOPIC = "cache_generate.active_support"
+          CACHE_FETCH_HIT_TOPIC = "cache_fetch_hit.active_support"
+          CACHE_WRITE_TOPIC = "cache_write.active_support"
+          CACHE_DELETE_TOPIC = "cache_delete.active_support"
+
+          # Instruments Rails ActiveSupport events for opentracing.
+          # Returns a lambda, which, when called will unsubscribe from the notifications
+          def self.instrument
+            subscriptions = [
+              ::ActiveSupport::Notifications.subscribe(CACHE_READ_TOPIC, CacheReadInstrumenter.new),
+              ::ActiveSupport::Notifications.subscribe(CACHE_GENERATE_TOPIC, CacheGenerateInstrumenter.new),
+              ::ActiveSupport::Notifications.subscribe(CACHE_FETCH_HIT_TOPIC, CacheFetchHitInstrumenter.new),
+              ::ActiveSupport::Notifications.subscribe(CACHE_WRITE_TOPIC, CacheWriteInstrumenter.new),
+              ::ActiveSupport::Notifications.subscribe(CACHE_DELETE_TOPIC, CacheDeleteInstrumenter.new),
+            ]
+
+            create_unsubscriber subscriptions
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,19 +8,13 @@ module Labkit
       # RailsCommon is a mixin for providing instrumentation
       # functionality for the rails instrumentation classes
       module RailsCommon
-        extend ActiveSupport::Concern
+        extend ::ActiveSupport::Concern
 
         class_methods do
           def create_unsubscriber(subscriptions)
-            -> { subscriptions.each { |subscriber| ActiveSupport::Notifications.unsubscribe(subscriber) } }
+            -> { subscriptions.each { |subscriber| ::ActiveSupport::Notifications.unsubscribe(subscriber) } }
           end
         end
-
-        def generate_span_for_notification(operation_name, start, finish, payload, tags)
-          exception = payload[:exception]
-
-          TracingUtils.postnotify_span(operation_name, start, finish, tags: tags, exception: exception)
-        end
       end
     end
   end

data/lib/labkit/tracing/redis/redis_interceptor_helper.rb

@@ -8,7 +8,7 @@ module Labkit
       # RedisInterceptorHelper is a helper for the RedisInterceptor. This is not a public API
       class RedisInterceptorHelper
         # For optimization, compile this once
-        MASK_REDIS_RE = /^([\w-]+(?:\W+[\w-]+(?:\W+[\w-]+)?)?)(.?)/.freeze
+        MASK_REDIS_RE = /^([\w{}-]+(?:\W+[\w{}-]+(?:\W+[\w{}-]+)?)?)(.?)/.freeze
 
         def self.call_with_tracing(command, client)
           Labkit::Tracing::TracingUtils.with_tracing(operation_name: "redis.call", tags: tags_from_command(command, client)) do |_span|
@@ -99,6 +99,7 @@ module Labkit
           return "" if argument.empty?
 
           matches = argument.match(MASK_REDIS_RE)
+
           matches[2].empty? ? matches[0] : matches[0] + "*****"
         end
         private_class_method :mask_redis_arg

data/lib/labkit/tracing/tracing_utils.rb

@@ -12,9 +12,7 @@ module Labkit
         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
+        log_common_fields_on_span(span, operation_name)
 
         begin
           yield span
@@ -35,11 +33,19 @@ module Labkit
       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)
 
+        log_common_fields_on_span(span, operation_name)
         log_exception_on_span(span, exception) if exception
 
         span.finish(end_time: 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)
+      end
+
       # Add exception logging to a span
       def self.log_exception_on_span(span, exception)
         span.set_tag("error", true)
@@ -60,6 +66,14 @@ module Labkit
           { :"event" => "error", :"error.kind" => exception.class.to_s, :"error.object" => Labkit::Logging::Sanitizer.sanitize_field(exception.to_s) }
         end
       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) }
+        end
+
+        @include_stacktrace[operation_name]
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitlab-labkit
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.2
 platform: ruby
 authors:
 - Andrew Newdigate
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-25 00:00:00.000000000 Z
+date: 2020-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -301,9 +301,22 @@ files:
 - lib/labkit/tracing/jaeger_factory.rb
 - lib/labkit/tracing/rack_middleware.rb
 - lib/labkit/tracing/rails.rb
-- lib/labkit/tracing/rails/action_view_subscriber.rb
-- lib/labkit/tracing/rails/active_record_subscriber.rb
-- lib/labkit/tracing/rails/active_support_subscriber.rb
+- lib/labkit/tracing/rails/abstract_instrumenter.rb
+- lib/labkit/tracing/rails/action_view.rb
+- lib/labkit/tracing/rails/action_view/render_collection_instrumenter.rb
+- lib/labkit/tracing/rails/action_view/render_partial_instrumenter.rb
+- lib/labkit/tracing/rails/action_view/render_template_instrumenter.rb
+- lib/labkit/tracing/rails/action_view/subscriber.rb
+- lib/labkit/tracing/rails/active_record.rb
+- lib/labkit/tracing/rails/active_record/sql_instrumenter.rb
+- lib/labkit/tracing/rails/active_record/subscriber.rb
+- lib/labkit/tracing/rails/active_support.rb
+- lib/labkit/tracing/rails/active_support/cache_delete_instrumenter.rb
+- lib/labkit/tracing/rails/active_support/cache_fetch_hit_instrumenter.rb
+- lib/labkit/tracing/rails/active_support/cache_generate_instrumenter.rb
+- 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/rails/rails_common.rb
 - lib/labkit/tracing/redis.rb
 - lib/labkit/tracing/redis/redis_interceptor.rb

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

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module Labkit
-  module Tracing
-    module Rails
-      # ActionViewSubscriber bridges action view notifications to
-      # the distributed tracing subsystem
-      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

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Labkit
-  module Tracing
-    module Rails
-      # ActiveRecordSubscriber bridges active record notifications to
-      # the distributed tracing subsystem
-      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/active_support_subscriber.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Labkit
-  module Tracing
-    module Rails
-      # ActiveSupport bridges action active support notifications to
-      # the distributed tracing subsystem
-      class ActiveSupportSubscriber
-        include RailsCommon
-
-        COMPONENT_TAG = "ActiveSupport"
-
-        CACHE_READ_TOPIC = "cache_read.active_support"
-        CACHE_GENERATE_TOPIC = "cache_generate.active_support"
-        CACHE_FETCH_HIT_TOPIC = "cache_fetch_hit.active_support"
-        CACHE_WRITE_TOPIC = "cache_write.active_support"
-        CACHE_DELETE_TOPIC = "cache_delete.active_support"
-
-        # Instruments Rails ActiveSupport events for opentracing.
-        # Returns a lambda, which, when called will unsubscribe from the notifications
-        def self.instrument
-          subscriber = new
-
-          subscriptions = [
-            ActiveSupport::Notifications.subscribe(CACHE_READ_TOPIC) do |_, start, finish, _, payload|
-              subscriber.notify_cache_read(start, finish, payload)
-            end,
-            ActiveSupport::Notifications.subscribe(CACHE_GENERATE_TOPIC) do |_, start, finish, _, payload|
-              subscriber.notify_cache_generate(start, finish, payload)
-            end,
-            ActiveSupport::Notifications.subscribe(CACHE_FETCH_HIT_TOPIC) do |_, start, finish, _, payload|
-              subscriber.notify_cache_fetch_hit(start, finish, payload)
-            end,
-            ActiveSupport::Notifications.subscribe(CACHE_WRITE_TOPIC) do |_, start, finish, _, payload|
-              subscriber.notify_cache_write(start, finish, payload)
-            end,
-            ActiveSupport::Notifications.subscribe(CACHE_DELETE_TOPIC) do |_, start, finish, _, payload|
-              subscriber.notify_cache_delete(start, finish, payload)
-            end,
-          ]
-
-          create_unsubscriber subscriptions
-        end
-
-        # For more information on the payloads: https://guides.rubyonrails.org/active_support_instrumentation.html#active-support
-        def notify_cache_read(start, finish, payload)
-          generate_span_for_notification("cache_read", start, finish, payload, tags_for_cache_read(payload))
-        end
-
-        def notify_cache_generate(start, finish, payload)
-          generate_span_for_notification("cache_generate", start, finish, payload, tags_for_key(payload))
-        end
-
-        def notify_cache_fetch_hit(start, finish, payload)
-          generate_span_for_notification("cache_fetch_hit", start, finish, payload, tags_for_key(payload))
-        end
-
-        def notify_cache_write(start, finish, payload)
-          generate_span_for_notification("cache_write", start, finish, payload, tags_for_key(payload))
-        end
-
-        def notify_cache_delete(start, finish, payload)
-          generate_span_for_notification("cache_delete", start, finish, payload, tags_for_key(payload))
-        end
-
-        private
-
-        def tags_for_cache_read(payload)
-          {
-            "component" => COMPONENT_TAG,
-            "cache.key" => payload[:key],
-            "cache.hit" => payload[:hit],
-            "cache.super_operation" => payload[:super_operation],
-          }
-        end
-
-        def tags_for_key(payload)
-          {
-            "component" => COMPONENT_TAG,
-            "cache.key" => payload[:key],
-          }
-        end
-      end
-    end
-  end
-end