opentelemetry-exporters-datadog 0.1.0

data/lib/opentelemetry-exporters-datadog.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache 2.0 license (see LICENSE).
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2020 Datadog, Inc.
+
+require 'opentelemetry/exporters/datadog'

data/lib/opentelemetry/exporters/datadog.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache 2.0 license (see LICENSE).
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2020 Datadog, Inc.
+
+# require_relative './datadog/exporter.rb'
+# require_relative './datadog/version.rb'
+# require_relative './datadog/datadog_span_processor.rb'
+# require_relative './datadog/propagator.rb'
+# require_relative './datadog_probability_sampler'
+require 'opentelemetry/exporters/datadog/exporter'
+require 'opentelemetry/exporters/datadog/version'
+require 'opentelemetry/exporters/datadog/datadog_span_processor'
+require 'opentelemetry/exporters/datadog/propagator'
+require 'opentelemetry/exporters/datadog/datadog_probability_sampler'
+
+# OpenTelemetry is an open source observability framework, providing a
+# general-purpose API, SDK, and related tools required for the instrumentation
+# of cloud-native software, frameworks, and libraries.
+#
+# The OpenTelemetry module provides global accessors for telemetry objects.
+# See the documentation for the `opentelemetry-api` gem for details.
+module OpenTelemetry
+end

data/lib/opentelemetry/exporters/datadog/datadog_probability_sampler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache 2.0 license (see LICENSE).
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2020 Datadog, Inc.
+
+require 'opentelemetry/sdk/trace/samplers/probability_sampler'
+require 'opentelemetry/sdk/trace/samplers/decision'
+require 'opentelemetry/sdk/trace/samplers/result'
+
+module OpenTelemetry
+  module Exporters
+    module Datadog
+      # Implements sampling based on a probability but records all spans regardless.
+      class DatadogProbabilitySampler < OpenTelemetry::SDK::Trace::Samplers::ProbabilitySampler
+        RECORD_AND_SAMPLED = OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_AND_SAMPLED)
+        RECORD = OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD)
+
+        private_constant(:RECORD_AND_SAMPLED, :RECORD)
+
+        # @api private
+        #
+        # See {Samplers}.
+        def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+          # Ignored for sampling decision: links, name, kind, attributes.
+
+          if sample?(trace_id, parent_context)
+            RECORD_AND_SAMPLED
+          else
+            RECORD
+          end
+        end
+
+        # Returns a new sampler. The probability of sampling a trace is equal
+        # to that of the specified probability.
+        #
+        # @param [Numeric] probability The desired probability of sampling.
+        #   Must be within [0.0, 1.0].
+        def self.default_with_probability(probability = 1.0)
+          raise ArgumentError, 'probability must be in range [0.0, 1.0]' unless (0.0..1.0).include?(probability)
+
+          new(probability,
+              ignore_parent: false,
+              apply_to_remote_parent: :root_spans_and_remote_parent,
+              apply_to_all_spans: :root_spans_and_remote_parent)
+        end
+
+        DEFAULT = new(1.0,
+                      ignore_parent: false,
+                      apply_to_remote_parent: :root_spans_and_remote_parent,
+                      apply_to_all_spans: :root_spans_and_remote_parent)
+      end
+    end
+  end
+end

data/lib/opentelemetry/exporters/datadog/datadog_span_processor.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache 2.0 license (see LICENSE).
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2020 Datadog, Inc.
+
+require 'timeout'
+
+module OpenTelemetry
+  module Exporters
+    module Datadog
+      # Implementation of the duck type SpanProcessor that batches spans
+      # exported by the SDK into complete traces then pushes them
+      # to the exporter pipeline.
+      #
+      # All spans reported by the SDK implementation are first added to a
+      # synchronized in memory trace storage (with a {max_queue_size}
+      # maximum size, of trace size {max_trace_size} after the size of
+      # either is reached spans are dropped). When traces are designated
+      # as "complete" they're added to a queue that is exported every
+      # schedule_delay_millis to the exporter pipeline in batches of
+      # completed traces. The datadog writer and transport supplied
+      # to the exporter handle the bulk of the timeout and retry logic.
+      class DatadogSpanProcessor
+        SCHEDULE_DELAY_MILLIS = 3_000
+        MAX_QUEUE_SIZE = 2048
+        MAX_TRACE_SIZE = 1024
+        private_constant(:SCHEDULE_DELAY_MILLIS, :MAX_QUEUE_SIZE, :MAX_TRACE_SIZE)
+
+        def initialize(exporter:,
+                       schedule_delay_millis: SCHEDULE_DELAY_MILLIS,
+                       max_queue_size: MAX_QUEUE_SIZE,
+                       max_trace_size: MAX_TRACE_SIZE)
+          raise ArgumentError if max_trace_size > max_queue_size
+
+          @exporter = exporter
+          @mutex = Mutex.new
+          @condition = ConditionVariable.new
+          @keep_running = true
+          @delay_seconds = schedule_delay_millis / 1000.0
+          @max_queue_size = max_queue_size
+          @max_trace_size = max_trace_size
+          @spans = []
+          @thread = Thread.new { work }
+
+          @traces = {}
+          @traces_spans_count = {}
+          @traces_spans_ended_count = {}
+          @check_traces_queue = []
+          @_spans_dropped = false
+        end
+
+        # datadog trace-agent endpoint requires a complete trace to be sent
+        # threadsafe may block on lock
+        def on_start(span)
+          context = span.context
+          trace_id = context.trace_id
+
+          lock do
+            if all_spans_count(traces_spans_count) >= max_queue_size
+              # instead of just dropping all new spans, dd-trace-rb drops a random trace
+              # https://github.com/DataDog/dd-trace-rb/blob/c6fbf2410a60495f1b2d8912bf7ea7dc63422141/lib/ddtrace/buffer.rb#L34-L36
+              # It allows for a more fair usage of the queue when under stress load,
+              # and will create proportional representation of code paths being instrumented at stress time.
+              unfinished_trace_id = fetch_unfinished_trace_id
+
+              # if there are no unfinished traces able to be dropped, don't add more spans, and return early
+              if unfinished_trace_id.nil?
+                OpenTelemetry.logger.warn('Max spans for all traces, spans will be dropped')
+                @_spans_dropped = true
+                return
+              end
+
+              drop_unfinished_trace(unfinished_trace_id)
+              OpenTelemetry.logger.warn('Max spans for all traces, traces will be dropped')
+            end
+
+            if traces[trace_id].nil?
+              traces[trace_id] = [span]
+              traces_spans_count[trace_id] = 1
+            else
+              if traces[trace_id].size >= max_trace_size
+                OpenTelemetry.logger.warn('Max spans for trace, spans will be dropped')
+                @_spans_dropped = true
+                return
+              end
+
+              traces[trace_id] << span
+              traces_spans_count[trace_id] += 1
+            end
+          end
+        end
+
+        # adds a span to the batcher, threadsafe may block on lock
+        def on_finish(span)
+          if @keep_running == false
+            OpenTelemetry.logger.warn('Already shutdown, dropping span')
+            return
+          end
+
+          # TODO: determine if all "not-sampled" spans still get passed to on_finish?
+          # If so then we don't need to account for Probability Sampling
+          # and can likely incorporate Priority Sampling from DD
+          # If not, then we need to ensure the rate from OpenTelemetry.tracer_provider.active_trace_config.sampler
+          # can be expoed to the span or attached to spanData in some way
+          # return unless span.context.trace_flags.sampled?
+
+          context = span.context
+          trace_id = context.trace_id
+
+          lock do
+            if traces_spans_ended_count[trace_id].nil?
+              traces_spans_ended_count[trace_id] = 1
+            else
+              traces_spans_ended_count[trace_id] += 1
+            end
+
+            check_traces_queue.unshift(trace_id) if trace_exportable?(trace_id)
+          end
+        end
+
+        # TODO: test this explicitly.
+        # Export all ended traces to the configured `Exporter` that have not yet
+        # been exported.
+        #
+        # This method should only be called in cases where it is absolutely
+        # necessary, such as when using some FaaS providers that may suspend
+        # the process after an invocation, but before the `Processor` exports
+        # the completed spans.
+        def force_flush
+          snapshot = lock { fetch_batch }
+          export_batch(snapshot)
+        end
+
+        # shuts the consumer thread down and flushes the current accumulated buffer
+        # will block until the thread is finished
+        def shutdown
+          lock do
+            @keep_running = false
+            @condition.signal
+          end
+
+          @thread.join
+          force_flush
+          @exporter.shutdown
+        end
+
+        private
+
+        attr_reader :check_traces_queue, :max_queue_size, :max_trace_size, :traces, :traces_spans_count, :traces_spans_ended_count
+
+        def work
+          while @keep_running
+            trace_spans = lock do
+              @condition.wait(@mutex, @delay_seconds) if @keep_running
+              @condition.wait(@mutex, @delay_seconds) while check_traces_queue.empty? && @keep_running
+              return unless @keep_running
+
+              fetch_batch
+            end
+
+            export_batch(trace_spans)
+          end
+        end
+
+        def export_batch(trace_spans)
+          return if trace_spans.empty?
+
+          trace_spans.each do |spans|
+            @exporter.export(spans)
+          rescue StandardError => e
+            OpenTelemetry.logger.warn("Exception while exporting Span batch. #{e.message} , #{e.backtrace}")
+          end
+        end
+
+        def trace_exportable?(trace_id)
+          traces_spans_count[trace_id] - traces_spans_ended_count[trace_id] <= 0 if traces_spans_count.key?(trace_id) && traces_spans_ended_count.key?(trace_id)
+        end
+
+        def all_spans_count(traces_spans_count)
+          traces_spans_count.values.sum
+        end
+
+        def fetch_batch
+          export_traces = []
+
+          check_traces_queue.reverse_each do |trace_id|
+            next unless trace_exportable?(trace_id)
+
+            export_traces << fetch_spans(traces.delete(trace_id))
+            check_traces_queue.delete(trace_id)
+            traces_spans_count.delete(trace_id)
+            traces_spans_ended_count.delete(trace_id)
+          end
+
+          export_traces
+        end
+
+        def fetch_spans(spans)
+          spans.map!(&:to_span_data)
+        end
+
+        def fetch_unfinished_trace_id
+          # don't delete potentially finished trace awaiting export
+          unfinished_traces = traces.keys - check_traces_queue
+          unfinished_traces[rand(unfinished_traces.length)]
+        end
+
+        def drop_unfinished_trace(trace_id)
+          traces.delete(trace_id)
+          traces_spans_count.delete(trace_id)
+          traces_spans_ended_count.delete(trace_id)
+        end
+
+        def lock
+          @mutex.synchronize do
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/exporters/datadog/exporter.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache 2.0 license (see LICENSE).
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2020 Datadog, Inc.
+
+require 'uri'
+require 'ddtrace'
+require 'opentelemetry/sdk'
+require 'opentelemetry/exporters/datadog/exporter/span_encoder'
+# require_relative './exporter/span_encoder.rb'
+
+module OpenTelemetry
+  module Exporters
+    module Datadog
+      # SpanExporter allows different tracing services to export
+      # recorded data for sampled spans in their own format.
+      #
+      # To export data an exporter MUST be registered to the {TracerProvider} using
+      # a {DatadogSpanProcessorr}.
+      class Exporter
+        DEFAULT_AGENT_URL = 'http://localhost:8126'
+        DEFAULT_SERVICE_NAME = 'my_service'
+        SUCCESS = begin
+                    OpenTelemetry::SDK::Trace::Export::SUCCESS
+                  rescue NameError
+                    0
+                  end
+        FAILURE = begin
+                    OpenTelemetry::SDK::Trace::Export::FAILURE
+                  rescue NameError
+                    1
+                  end
+        private_constant(:SUCCESS, :FAILURE)
+
+        def initialize(service_name: nil, agent_url: nil, env: nil, version: nil, tags: nil)
+          @shutdown = false
+          @agent_url = agent_url || ENV.fetch('DD_TRACE_AGENT_URL', DEFAULT_AGENT_URL)
+          @service = service_name || ENV.fetch('DD_SERVICE', DEFAULT_SERVICE_NAME)
+
+          @env = env || ENV.fetch('DD_ENV', nil)
+          @version = version || ENV.fetch('DD_VERSION', nil)
+          @tags = tags || ENV.fetch('DD_TAGS', nil)
+
+          @agent_writer = get_writer(@agent_url)
+
+          @span_encoder = SpanEncoder.new
+        end
+
+        # Called to export sampled {Span}s.
+        #
+        # @param [Enumerable<Span>] spans the list of sampled {Span}s to be
+        #   exported.
+        # @return [Integer] the result of the export.
+        def export(spans)
+          return FAILURE if @shutdown
+
+          if @agent_writer
+            datadog_spans = @span_encoder.translate_to_datadog(spans, @service, @env, @version, @tags)
+            @agent_writer.write(datadog_spans)
+            SUCCESS
+          else
+            OpenTelemetry.logger.debug('Agent writer not set')
+            FAILURE
+          end
+        end
+
+        # Called when {TracerProvider#shutdown} is called, if this exporter is
+        # registered to a {TracerProvider} object.
+        def shutdown
+          @shutdown = true
+        end
+
+        private
+
+        def get_writer(uri)
+          uri_parsed = URI.parse(uri)
+
+          if %w[http https].include?(uri_parsed.scheme)
+            hostname = uri_parsed.hostname
+            port = uri_parsed.port
+
+            adapter = ::Datadog::Transport::HTTP::Adapters::Net.new(hostname, port)
+
+            transport = ::Datadog::Transport::HTTP.default do |t|
+              t.adapter adapter
+            end
+
+            ::Datadog::Writer.new(transport: transport)
+          elsif uri_parsed.to_s.index('/sock')
+            # handle uds path
+            transport = ::Datadog::Transport::HTTP.default do |t|
+              t.adapter :unix, uri_parsed.to_s
+            end
+
+            ::Datadog::Writer.new(transport: transport)
+          else
+            OpenTelemetry.logger.warn('only http/https and uds is supported at this time')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/exporters/datadog/exporter/span_encoder.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+# Unless explicitly stated otherwise all files in this repository are licensed
+# under the Apache 2.0 license (see LICENSE).
+# This product includes software developed at Datadog (https://www.datadoghq.com/).
+# Copyright 2020 Datadog, Inc.
+
+require 'ddtrace/span'
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/redis/ext'
+require 'opentelemetry/trace/status'
+require 'ddtrace/distributed_tracing/headers/headers'
+
+module OpenTelemetry
+  module Exporters
+    module Datadog
+      class Exporter
+        # @api private
+        class SpanEncoder
+          ENV_KEY = 'env'
+          VERSION_KEY = 'version'
+          DD_ORIGIN = '_dd_origin'
+          USER_REJECT = -1
+          AUTO_REJECT = 0
+          AUTO_KEEP = 1
+          USER_KEEP = 2
+          INTERNAL_TRACE_REGEX = %r{/v\d\.\d/traces}.freeze
+          SAMPLE_RATE_METRIC_KEY = '_sample_rate'
+          SAMPLING_PRIORITY_KEY = '_sampling_priority_v1'
+          ORIGIN_REGEX = /#{DD_ORIGIN}\=(.*?)($|,)/.freeze
+          PROBABILITY_REGEX = /\d[.]\d{1,6}/.freeze
+          TRUNCATION_HELPER = ::Datadog::DistributedTracing::Headers::Headers.new({})
+
+          INSTRUMENTATION_SPAN_TYPES = {
+            'OpenTelemetry::Instrumentation::Ethon' => ::Datadog::Ext::HTTP::TYPE_OUTBOUND,
+            'OpenTelemetry::Instrumentation::Excon' => ::Datadog::Ext::HTTP::TYPE_OUTBOUND,
+            'OpenTelemetry::Instrumentation::Faraday' => ::Datadog::Ext::HTTP::TYPE_OUTBOUND,
+            'OpenTelemetry::Instrumentation::Mysql2' => ::Datadog::Ext::SQL::TYPE,
+            'OpenTelemetry::Instrumentation::Net::HTTP' => ::Datadog::Ext::HTTP::TYPE_OUTBOUND,
+            'OpenTelemetry::Instrumentation::Rack' => ::Datadog::Ext::HTTP::TYPE_INBOUND,
+            'OpenTelemetry::Instrumentation::Redis' => ::Datadog::Contrib::Redis::Ext::TYPE,
+            'OpenTelemetry::Instrumentation::RestClient' => ::Datadog::Ext::HTTP::TYPE_OUTBOUND,
+            'OpenTelemetry::Instrumentation::Sidekiq' => ::Datadog::Ext::AppTypes::WORKER,
+            'OpenTelemetry::Instrumentation::Sinatra' => ::Datadog::Ext::HTTP::TYPE_INBOUND
+          }.freeze
+
+          def translate_to_datadog(otel_spans, service, env = nil, version = nil, tags = nil) # rubocop:disable Metrics/AbcSize
+            datadog_spans = []
+
+            default_tags = get_default_tags(tags) || {}
+
+            otel_spans.each do |span|
+              trace_id, span_id, parent_id = get_trace_ids(span)
+              span_type = get_span_type(span)
+              span_name = get_span_name(span)
+
+              datadog_span = ::Datadog::Span.new(nil, span_name,
+                                                 service: service,
+                                                 trace_id: trace_id,
+                                                 parent_id: parent_id,
+                                                 resource: get_resource(span),
+                                                 span_type: span_type)
+
+              # span_id is autogenerated so have to override
+              datadog_span.span_id = span_id
+              datadog_span.start_time = span.start_timestamp
+              datadog_span.end_time = span.end_timestamp
+
+              # set span.error, span tag error.msg/error.type
+              if span.status && span.status.canonical_code != OpenTelemetry::Trace::Status::OK
+                datadog_span.status = 1
+
+                exception_type, exception_msg, exception_stack = get_exception_info(span)
+
+                if exception_type && exception_msg && exception_stack
+                  datadog_span.set_tag('error.type', exception_type)
+                  datadog_span.set_tag('error.msg', exception_msg)
+                  datadog_span.set_tag('error.stack', exception_stack)
+                end
+              end
+
+              # set default tags
+              default_tags&.keys&.each do |attribute|
+                datadog_span.set_tag(attribute, span.attributes[attribute])
+              end
+
+              origin = get_origin_string(span)
+              datadog_span.set_tag(DD_ORIGIN, origin) if origin && parent_id.zero?
+              datadog_span.set_tag(VERSION_KEY, version) if version && parent_id.zero?
+              datadog_span.set_tag(ENV_KEY, env) if env
+
+              # set tags - takes precedence over env vars
+              span.attributes&.keys&.each do |attribute|
+                datadog_span.set_tag(attribute, span.attributes[attribute])
+              end
+
+              sampling_rate = get_sampling_rate(span)
+
+              if filter_internal_request?(span)
+                datadog_span.set_metric(SAMPLE_RATE_METRIC_KEY, USER_REJECT)
+              elsif sampling_rate
+                datadog_span.set_metric(SAMPLE_RATE_METRIC_KEY, sampling_rate)
+              end
+
+              datadog_spans << datadog_span
+            end
+
+            datadog_spans
+          end
+
+          def int64(hex_string, base)
+            TRUNCATION_HELPER.value_to_id(hex_string, base)
+          end
+
+          private
+
+          def get_trace_ids(span)
+            trace_id = int64(span.trace_id.unpack1('H*'), 16)
+            span_id = int64(span.span_id.unpack1('H*'), 16)
+            parent_id = span.parent_span_id ? int64(span.parent_span_id.unpack1('H*'), 16) || 0 : 0
+
+            [trace_id, span_id, parent_id]
+          rescue StandardError => e
+            OpenTelemetry.logger.debug("error encoding trace_ids #{e.message}")
+            [0, 0, 0]
+          end
+
+          def get_span_type(span)
+            # Get Datadog span type
+            return unless span.instrumentation_library
+
+            instrumentation_name = span.instrumentation_library.name
+            INSTRUMENTATION_SPAN_TYPES[instrumentation_name]
+          rescue NoMethodError
+            span.name
+          end
+
+          def get_exception_info(span)
+            # Parse span exception type, msg, and stack from span events
+            error_event = span&.events&.find { |ev| ev.name == 'error' }
+
+            return unless error_event
+
+            err_type = error_event.attributes['error.type']
+            err_msg = error_event.attributes['error.msg']
+            err_stack = error_event.attributes['error.stack']
+
+            [err_type, err_msg, err_stack]
+          rescue StandardError => e
+            OpenTelemetry.logger.debug("error on exception info from span events: #{span.events} , #{e.message}")
+          end
+
+          def get_resource(span)
+            # Get resource name for http related spans
+            # TODO: how to handle resource naming for broader span types, ie db/cache/queue etc
+
+            if span.attributes&.key?('http.method')
+              route = span.attributes['http.route'] || span.attributes['http.target']
+
+              return span.attributes['http.method'] + ' ' + route if route
+
+              return span.attributes['http.method']
+            end
+
+            span.name
+          rescue StandardError => e
+            OpenTelemetry.logger.debug("error encoding trace_ids #{e.message}")
+            span.name
+          end
+
+          def get_sampling_rate(span)
+            get_rate_from_description(span) || 1 if span.trace_flags&.sampled?
+          end
+
+          def get_span_name(span)
+            # Get span name by using instrumentation and kind while backing off to
+            instrumentation_name = span.instrumentation_library&.name
+            kind = span.kind
+            instrumentation_name && kind ? "#{instrumentation_name.to_s.gsub(':', '_')}.#{kind}" : span.name
+          rescue NoMethodError
+            span.name
+          end
+
+          def get_origin_string(span)
+            tracestate = begin
+                           span.tracestate
+                         rescue NoMethodError
+                           nil
+                         end
+
+            return if tracestate.nil? || tracestate.index(DD_ORIGIN).nil?
+
+            # Depending on the edge cases in tracestate values this might be
+            # less efficient than mapping string => array => hash.
+            origin_value = tracestate.match(ORIGIN_REGEX)
+            return if origin_value.nil?
+
+            origin_value[1]
+          rescue StandardError => e
+            OpenTelemetry.logger.debug("error getting origin from trace state, #{e.message}")
+          end
+
+          def get_default_tags(tags)
+            # Parse a string of tags typically provided via environment variables.
+            # The expected string is of the form: "key1:value1,key2:value2"
+
+            return {} if tags.nil?
+
+            tag_map = tags.split(',').map { |kv| kv.split(':') }.to_h
+
+            if tag_map.keys&.index('') || tag_map.values&.index('') || tag_map.values&.any? { |v| v.ends_with?(':') }
+              OpenTelemetry.logger.debug("malformed tag in default tags: #{tags}")
+              {}
+            else
+              tag_map
+            end
+          end
+
+          def get_rate_from_description(span)
+            # format to parse of sampler description is
+            # "ProbabilitySampler{1.000000}" or
+            # "AlwaysOnSampler" / "AlwaysOffSampler"
+            # TODO: remove begin/rescue block if PR #282 is accepted+released
+            sampler = begin
+                        span.sampler
+                      rescue NoMethodError
+                        nil
+                      end
+
+            return nil unless sampler&.is_a?(ProbabilitySampler)
+
+            rate = sampler.description&.match(PROBABILITY_REGEX)
+
+            return nil unless rate
+
+            rate[0].to_f(4)
+          rescue StandardError => e
+            # rescue just in case the format changes dramatically in the future
+            OpenTelemetry.logger.warn("error while extracting sampling rate #{e.message} , #{e.backtrace}")
+            nil
+          end
+
+          def filter_internal_request?(span)
+            span.attributes['http.route'].match(INTERNAL_TRACE_REGEX) if span.attributes&.key?('http.route')
+          end
+        end
+      end
+    end
+  end
+end