instana 1.217.1 → 2.1.0

data/lib/instana/{tracing → trace}/span_context.rb

@@ -2,10 +2,8 @@
 # (c) Copyright Instana Inc. 2017
 
 module Instana
-  class SpanContext
-    attr_accessor :trace_id
-    attr_accessor :span_id
-    attr_accessor :baggage
+  class SpanContext < OpenTelemetry::Trace::SpanContext
+    attr_accessor :trace_id, :span_id, :baggage
     attr_reader :level
 
     # Create a new SpanContext
@@ -15,9 +13,20 @@ module Instana
     # @param level [Integer] default 1
     # @param baggage [Hash] baggage applied to this trace
     #
-    def initialize(tid, sid, level = 1, baggage = {})
-      @trace_id = tid
-      @span_id = sid
+    def initialize( # rubocop:disable Lint/MissingSuper, Metrics/ParameterLists
+      trace_id: Trace.generate_trace_id,
+      span_id: Trace.generate_span_id,
+      trace_flags: OpenTelemetry::Trace::TraceFlags::DEFAULT, # Todo - implement traceflags
+      tracestate: OpenTelemetry::Trace::Tracestate::DEFAULT,  # Todo - implement tracestates
+      remote: false,
+      level: 1,
+      baggage: {}
+    )
+      @trace_id = trace_id
+      @span_id = span_id
+      @trace_flags = trace_flags
+      @tracestate = tracestate
+      @remote = remote
       @level = Integer(level || 1)
       @baggage = baggage || {}
     end
@@ -55,7 +64,7 @@ module Instana
     end
 
     def valid?
-      @baggage && @trace_id && !@trace_id.emtpy?
+      @baggage && @trace_id && !@trace_id.empty?
     end
 
     def active?

data/lib/instana/trace/span_kind.rb

@@ -0,0 +1,51 @@
+# (c) Copyright IBM Corp. 2025
+
+module Instana
+  # Type of span. Can be used to specify additional relationships between spans in addition to a
+  # parent/child relationship. For API ergonomics, use of the symbols rather than the constants
+  # may be preferred. For example:
+  #
+  #   span = tracer.on_start('op', kind: :client)
+  module SpanKind
+    # Instana specific spans
+    REGISTERED_SPANS = [:actioncontroller, :actionview, :activerecord, :excon,
+                        :memcache, :'net-http', :rack, :render, :'rpc-client',
+                        :'rpc-server', :'sidekiq-client', :'sidekiq-worker',
+                        :redis, :'resque-client', :'resque-worker', :'graphql.server', :dynamodb, :s3, :sns, :sqs, :'aws.lambda.entry', :activejob, :log, :"mail.actionmailer",
+                        :"aws.lambda.invoke", :mongo, :sequel].freeze
+    ENTRY_SPANS = [:rack, :'resque-worker', :'rpc-server', :'sidekiq-worker', :'graphql.server', :sqs,
+                   :'aws.lambda.entry'].freeze
+    EXIT_SPANS = [:activerecord, :excon, :'net-http', :'resque-client',
+                  :'rpc-client', :'sidekiq-client', :redis, :dynamodb, :s3, :sns, :sqs, :log, :"mail.actionmailer",
+                  :"aws.lambda.invoke", :mongo, :sequel].freeze
+    HTTP_SPANS = [:rack, :excon, :'net-http'].freeze
+
+    # Default value. Indicates that the span is used internally.
+    INTERNAL = :internal
+
+    # Indicates that the span covers server-side handling of an RPC or other remote request.
+    SERVER = :server
+
+    # Indicates that the span covers the client-side wrapper around an RPC or other remote request.
+    CLIENT = :client
+
+    # Indicates that the span describes producer sending a message to a broker. Unlike client and
+    # server, there is no direct critical path latency relationship between producer and consumer
+    # spans.
+    PRODUCER = :producer
+
+    # Indicates that the span describes consumer receiving a message from a broker. Unlike client
+    # and server, there is no direct critical path latency relationship between producer and
+    # consumer spans.
+    CONSUMER = :consumer
+
+    # Indicates an entry span. Equivalant to Server or Consumer
+    ENTRY = :entry
+
+    # Indicates an exit span. Equivalant to Client or Producer
+    EXIT = :exit
+
+    # Indicates an intermediate span. This used when sdk is used to produce intermediate traces
+    INTERMEDIATE = :intermediate
+  end
+end

data/lib/instana/trace/span_limits.rb

@@ -0,0 +1,63 @@
+# (c) Copyright IBM Corp. 2025
+
+require 'opentelemetry-common'
+
+module Instana
+  module Trace
+    # Class that holds global trace parameters.
+    class SpanLimits
+      # The global default max number of attributes per {Span}.
+      attr_reader :attribute_count_limit
+
+      # The global default max length of attribute value per {Span}.
+      attr_reader :attribute_length_limit
+
+      # The global default max number of {OpenTelemetry::SDK::Trace::Event}s per {Span}.
+      attr_reader :event_count_limit
+
+      # The global default max number of {OpenTelemetry::Trace::Link} entries per {Span}.
+      attr_reader :link_count_limit
+
+      # The global default max number of attributes per {OpenTelemetry::SDK::Trace::Event}.
+      attr_reader :event_attribute_count_limit
+
+      # The global default max length of attribute value per {OpenTelemetry::SDK::Trace::Event}.
+      attr_reader :event_attribute_length_limit
+
+      # The global default max number of attributes per {OpenTelemetry::Trace::Link}.
+      attr_reader :link_attribute_count_limit
+
+      # Returns a {SpanLimits} with the desired values.
+      #
+      # @return [SpanLimits] with the desired values.
+      # @raise [ArgumentError] if any of the max numbers are not positive.
+      def initialize(attribute_count_limit: Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT', 'OTEL_ATTRIBUTE_COUNT_LIMIT', default: 128)), # rubocop:disable Metrics/ParameterLists
+                     attribute_length_limit: OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT', 'OTEL_RUBY_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT',
+                                                                                         'OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT'),
+                     event_count_limit: Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_EVENT_COUNT_LIMIT', default: 128)),
+                     link_count_limit: Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_SPAN_LINK_COUNT_LIMIT', default: 128)),
+                     event_attribute_count_limit: Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT', default: 128)),
+                     event_attribute_length_limit: OpenTelemetry::Common::Utilities.config_opt('OTEL_EVENT_ATTRIBUTE_VALUE_LENGTH_LIMIT', 'OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT'),
+                     link_attribute_count_limit: Integer(OpenTelemetry::Common::Utilities.config_opt('OTEL_LINK_ATTRIBUTE_COUNT_LIMIT', default: 128)))
+        raise ArgumentError, 'attribute_count_limit must be positive' unless attribute_count_limit.positive?
+        raise ArgumentError, 'attribute_length_limit must not be less than 32' unless attribute_length_limit.nil? || Integer(attribute_length_limit) >= 32
+        raise ArgumentError, 'event_count_limit must be positive' unless event_count_limit.positive?
+        raise ArgumentError, 'link_count_limit must be positive' unless link_count_limit.positive?
+        raise ArgumentError, 'event_attribute_count_limit must be positive' unless event_attribute_count_limit.positive?
+        raise ArgumentError, 'event_attribute_length_limit must not be less than 32' unless event_attribute_length_limit.nil? || Integer(event_attribute_length_limit) >= 32
+        raise ArgumentError, 'link_attribute_count_limit must be positive' unless link_attribute_count_limit.positive?
+
+        @attribute_count_limit = attribute_count_limit
+        @attribute_length_limit = attribute_length_limit.nil? ? nil : Integer(attribute_length_limit)
+        @event_count_limit = event_count_limit
+        @link_count_limit = link_count_limit
+        @event_attribute_count_limit = event_attribute_count_limit
+        @event_attribute_length_limit = event_attribute_length_limit.nil? ? nil : Integer(event_attribute_length_limit)
+        @link_attribute_count_limit = link_attribute_count_limit
+      end
+
+      # The default {SpanLimits}.
+      DEFAULT = new
+    end
+  end
+end

data/lib/instana/{tracer.rb → trace/tracer.rb}

@@ -1,14 +1,14 @@
-# (c) Copyright IBM Corp. 2021
-# (c) Copyright Instana Inc. 2016
+# (c) Copyright IBM Corp. 2025
 
-require "instana/tracing/span"
-require "instana/tracing/span_context"
+require 'opentelemetry/trace/tracer'
+require 'instana/trace/span'
+require "instana/trace/span_context"
+require 'opentelemetry/context'
 
 module Instana
-  class Tracer
-    # Support ::Instana::Tracer.xxx call style for the instantiated tracer
+  class Tracer < OpenTelemetry::Trace::Tracer
     class << self
-      def method_missing(method, *args, &block)
+      def method_missing(method, *args, &block) # rubocop:disable Style/MissingRespondToMissing
         if ::Instana.tracer.respond_to?(method)
           ::Instana.tracer.send(method, *args, &block)
         else
@@ -17,7 +17,9 @@ module Instana
       end
     end
 
-    def initialize(logger: Instana.logger)
+    def initialize(_name, _version, tracer_provider, logger = Instana.logger)
+      super()
+      @tracer_provider = tracer_provider
       @current_span = Concurrent::ThreadLocalVar.new
       @logger = logger
     end
@@ -29,8 +31,8 @@ module Instana
 
     # @param [Instana::Span, NilClas] v the new current span
     # Set the value of the current span
-    def current_span=(v)
-      @current_span.value = v
+    def current_span=(value)
+      @current_span.value = value
     end
 
     #######################################
@@ -48,10 +50,10 @@ module Instana
     #     :span_id the ID of the parent span (must be an unsigned hex-string)
     #     :level specifies data collection level (optional)
     #
-    def start_or_continue_trace(name, kvs = {}, incoming_context = nil, &block)
+    def start_or_continue_trace(name, kvs = {}, incoming_context = nil)
       span = log_start_or_continue(name, kvs, incoming_context)
       yield(span)
-    rescue Exception => e
+    rescue Exception => e # rubocop:disable Lint/RescueException
       log_error(e)
       raise
     ensure
@@ -69,10 +71,10 @@ module Instana
     # @param name [String, Symbol] the name of the span to start
     # @param kvs [Hash] list of key values to be reported in this new span
     #
-    def trace(name, kvs = {}, &block)
+    def trace(name, kvs = {})
       span = log_entry(name, kvs)
       yield(span)
-    rescue Exception => e
+    rescue Exception => e # rubocop:disable Lint/RescueException
       log_error(e)
       raise
     ensure
@@ -100,12 +102,12 @@ module Instana
       # Handle the potential variations on `incoming_context`
       if incoming_context
         if incoming_context.is_a?(Hash)
-          if !incoming_context.empty?
+          unless incoming_context.empty?
             parent_context = SpanContext.new(
-              incoming_context[:trace_id],
-              incoming_context[:span_id],
-              incoming_context[:level],
-              {
+              trace_id: incoming_context[:trace_id],
+              span_id: incoming_context[:span_id],
+              level: incoming_context[:level],
+              baggage: {
                 external_trace_id: incoming_context[:external_trace_id],
                 external_state: incoming_context[:external_state]
               }
@@ -116,14 +118,14 @@ module Instana
         end
       end
 
-      if parent_context
-        self.current_span = Span.new(name, parent_ctx: parent_context)
-      else
-        self.current_span = Span.new(name)
-      end
+      self.current_span = if parent_context
+                            Span.new(name, parent_context)
+                          else
+                            Span.new(name)
+                          end
 
-      self.current_span.set_tags(kvs) unless kvs.empty?
-      self.current_span
+      current_span.set_tags(kvs) unless kvs.empty?
+      current_span
     end
 
     # Will establish a new span as a child of the current span
@@ -132,13 +134,13 @@ module Instana
     # @param name [String, Symbol] the name of the span to create
     # @param kvs [Hash] list of key values to be reported in the span
     #
-    def log_entry(name, kvs = nil, start_time = ::Instana::Util.now_in_ms, child_of = nil)
+    def log_entry(name, kvs = nil, _start_time = ::Instana::Util.now_in_ms, child_of = nil)
       return unless tracing? || child_of
 
-      new_span = if child_of.nil? && !self.current_span.nil?
-                   Span.new(name, parent_ctx: self.current_span, start_time: start_time)
+      new_span = if child_of.nil? && !current_span.nil?
+                   Span.new(name, current_span)
                  else
-                   Span.new(name, parent_ctx: child_of, start_time: start_time)
+                   Span.new(name, child_of)
                  end
       new_span.set_tags(kvs) if kvs
       self.current_span = new_span
@@ -149,17 +151,19 @@ module Instana
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_info(kvs)
-      return unless self.current_span
-      self.current_span.set_tags(kvs)
+      return unless current_span
+
+      current_span.set_tags(kvs)
     end
 
     # Add an error to the current span
     #
     # @param e [Exception] Add exception to the current span
     #
-    def log_error(e)
-      return unless self.current_span
-      self.current_span.add_error(e)
+    def log_error(error)
+      return unless current_span
+
+      current_span.record_exception(error)
     end
 
     # Closes out the current span
@@ -171,16 +175,16 @@ module Instana
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_exit(name, kvs = {})
-      return unless self.current_span
+      return unless current_span
 
-      if self.current_span.name != name
-        @logger.warn "Span mismatch: Attempt to end #{name} span but #{self.current_span.name} is active."
+      if current_span.name != name
+        @logger.warn "Span mismatch: Attempt to end #{name} span but #{current_span.name} is active."
       end
 
-      self.current_span.set_tags(kvs)
-      self.current_span.close
+      current_span.set_tags(kvs)
+      current_span.close
 
-      self.current_span = self.current_span.parent || nil
+      self.current_span = current_span.parent || nil
     end
 
     # Closes out the current span in the current trace
@@ -193,14 +197,14 @@ module Instana
     # @param kvs [Hash] list of key values to be reported in the span
     #
     def log_end(name, kvs = {}, end_time = ::Instana::Util.now_in_ms)
-      return unless self.current_span
+      return unless current_span
 
-      if self.current_span.name != name
-        @logger.warn "Span mismatch: Attempt to end #{name} span but #{self.current_span.name} is active."
+      if current_span.name != name
+        @logger.warn "Span mismatch: Attempt to end #{name} span but #{current_span.name} is active."
       end
 
-      self.current_span.set_tags(kvs)
-      self.current_span.close(end_time)
+      current_span.set_tags(kvs)
+      current_span.close(end_time)
       self.current_span = nil
     end
 
@@ -220,7 +224,7 @@ module Instana
     def log_async_entry(name, kvs)
       return unless tracing?
 
-      new_span = Span.new(name, parent_ctx: self.current_span)
+      new_span = Span.new(name, current_span)
       new_span.set_tags(kvs) unless kvs.empty?
       new_span
     end
@@ -239,8 +243,8 @@ module Instana
     # @param e [Exception] Add exception to the current span
     # @param span [Span] the span for this Async op (previously returned from `log_async_entry`)
     #
-    def log_async_error(e, span)
-      span.add_error(e)
+    def log_async_error(error, span)
+      span.record_exception(error)
     end
 
     # Closes out an asynchronous span
@@ -268,7 +272,7 @@ module Instana
       # The non-nil value of this instance variable
       # indicates if we are currently tracing
       # in this thread or not.
-      (self.current_span ? true : false) ||
+      (current_span ? true : false) ||
         (::Instana.config[:allow_exit_as_root] && ::Instana.config[:tracing][:enabled])
     end
 
@@ -280,9 +284,10 @@ module Instana
     # @return [Boolean]
     #
     def tracing_span?(name)
-      if self.current_span
-        return self.current_span.name == name
+      if current_span
+        return current_span.name == name
       end
+
       false
     end
 
@@ -291,8 +296,9 @@ module Instana
     # @return [SpanContext] or nil if not tracing
     #
     def context
-      return unless self.current_span
-      self.current_span.context
+      return unless current_span
+
+      current_span.context
     end
 
     # Used in the test suite, this resets the tracer to non-tracing state.
@@ -300,5 +306,51 @@ module Instana
     def clear!
       self.current_span = nil
     end
+
+    # Creates a span that is active during the execution of the provided block.
+    # The span is automatically closed when the block completes, whether it completes
+    # normally or with an exception.
+    #
+    # @param name [String, Symbol] the name of the span to create
+    # @param attributes [Hash, nil] optional attributes to set on the span
+    # @param links [Array<Link>, nil] optional links to associate with the span
+    # @param start_timestamp [Integer, nil] optional start time for the span in milliseconds
+    # @param kind [Symbol, nil] optional span kind (e.g., :internal, :client, :server)
+    #
+    # @return [Object] the return value of the block
+    #
+    # @note This method is a wrapper around the parent class implementation and
+    #   will only create a span if the Instana agent is ready and tracing is enabled.
+    #
+    def in_span(name, attributes: nil, links: nil, start_timestamp: nil, kind: nil)
+      return if !::Instana.agent.ready? || !::Instana.config[:tracing][:enabled]
+
+      super
+    end
+
+    # Starts a new span with the given parameters.
+    #
+    # @param name [String, Symbol] the name of the span to create (defaults to 'empty' if nil)
+    # @param with_parent [Context, nil] the parent context for the span (defaults to current context if nil)
+    # @param attributes [Hash, nil] optional attributes to set on the span
+    # @param links [Array<Link>, nil] optional links to associate with the span
+    # @param start_timestamp [Integer, nil] optional start time for the span in milliseconds
+    # @param kind [Symbol, nil] optional span kind (defaults to :internal if nil)
+    #
+    # @return [Span] the newly created span
+    #
+    # @note This method will only create a span if the Instana agent is ready and tracing is enabled.
+    #   Default values are set for nil parameters: name='empty', kind=:internal,
+    #   with_parent=current context, start_timestamp=current time.
+    #
+    def start_span(name, with_parent: nil, attributes: nil, links: nil, start_timestamp: ::Instana::Util.now_in_ms, kind: nil) # rubocop:disable Metrics/ParameterLists
+      return if !::Instana.agent.ready? || !::Instana.config[:tracing][:enabled]
+
+      with_parent ||= OpenTelemetry::Context.current
+      name ||= 'empty'
+      kind ||= :internal
+      start_timestamp ||= ::Instana::Util.now_in_ms
+      self.current_span = @tracer_provider.internal_start_span(name, kind, attributes, links, start_timestamp, with_parent, @instrumentation_scope)
+    end
   end
 end

data/lib/instana/trace/tracer_provider.rb

@@ -0,0 +1,198 @@
+# (c) Copyright IBM Corp. 2025
+
+require 'opentelemetry/trace/tracer_provider'
+require 'instana/samplers/samplers'
+require 'instana/trace/span_limits'
+require 'instana/trace/export'
+
+module Instana
+  module Trace
+    # {TracerProvider} is the Instana implementation of {OpenTelemetry::Trace::TracerProvider}.
+    class TracerProvider < OpenTelemetry::Trace::TracerProvider
+      Key = Struct.new(:name, :version)
+      private_constant(:Key)
+
+      attr_accessor :span_limits, :id_generator, :sampler
+      attr_reader :resource
+
+      # Returns a new {TracerProvider} instance.
+      #
+      # @param [optional Sampler] sampler The sampling policy for new spans
+      # @param [optional Resource] resource The resource to associate with spans
+      #   created by Tracers created by this TracerProvider
+      # @param [optional IDGenerator] id_generator The trace and span ID generation
+      #   policy
+      # @param [optional SpanLimits] span_limits The limits to apply to attribute,
+      #   event and link counts for Spans created by Tracers created by this
+      #   TracerProvider
+      #
+      # @return [TracerProvider]
+      # def initialize
+      #   super()
+      # end
+
+      def initialize(sampler: sampler_from_environment(Samplers.parent_based(root: Samplers::ALWAYS_ON)),
+                     resource: nil, # Instana::Resources::Resource.create
+                     id_generator: ::Instana::Trace,
+                     span_limits: SpanLimits::DEFAULT)
+        super()
+        @mutex = Mutex.new
+        @registry = {}
+        @registry_mutex = Mutex.new
+        @span_processors = []
+        @span_limits = span_limits
+        @sampler = sampler
+        @id_generator = id_generator
+        @stopped = false
+        @resource = resource
+      end
+
+      # Returns a {Tracer} instance.
+      #
+      # @param [optional String] name Instrumentation package name
+      # @param [optional String] version Instrumentation package version
+      #
+      # @return [Tracer]
+      def tracer(name = nil, version = nil)
+        name ||= ''
+        version ||= ''
+        ::Instana.logger.warn 'calling TracerProvider#tracer without providing a tracer name.' if name.empty?
+        @registry_mutex.synchronize { @registry[Key.new(name, version)] ||= Tracer.new(name, version, self) }
+      end
+
+      # Attempts to stop all the activity for this {TracerProvider}. Calls
+      # SpanProcessor#shutdown for all registered SpanProcessors.
+      #
+      # This operation may block until all the Spans are processed. Must be
+      # called before turning off the main application to ensure all data are
+      # processed and exported.
+      #
+      # After this is called all the newly created {Span}s will be no-op.
+      #
+      # @param [optional Numeric] timeout An optional timeout in seconds.
+      # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+      #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+      def shutdown(timeout: nil)
+        @mutex.synchronize do
+          if @stopped
+            ::Instana.logger.warn('calling Tracer#shutdown multiple times.')
+            return Export::FAILURE
+          end
+
+          start_time = Instana::Util.timeout_timestamp
+          results = @span_processors.map do |processor|
+            remaining_timeout = Instana::Util.maybe_timeout(timeout, start_time)
+            break [Export::TIMEOUT] if remaining_timeout&.zero?
+
+            processor.shutdown(timeout: remaining_timeout)
+          end
+          @stopped = true
+          results.max || Export::SUCCESS
+        end
+      end
+
+      # Immediately export all spans that have not yet been exported for all the
+      # registered SpanProcessors.
+      #
+      # 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.
+      #
+      # @param [optional Numeric] timeout An optional timeout in seconds.
+      # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
+      #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
+      def force_flush(timeout: nil)
+        @mutex.synchronize do
+          return Export::SUCCESS if @stopped
+
+          start_time = Instana::Util.timeout_timestamp
+          results = @span_processors.map do |processor|
+            remaining_timeout = Instana::Util.maybe_timeout(timeout, start_time)
+            return Export::TIMEOUT if remaining_timeout&.zero?
+
+            processor.force_flush(timeout: remaining_timeout)
+          end
+          results.max || Export::SUCCESS
+        end
+      end
+
+      # Adds a new SpanProcessor to this {Tracer}.
+      #
+      # @param span_processor the new SpanProcessor to be added.
+      def add_span_processor(span_processor)
+        @mutex.synchronize do
+          if @stopped
+            ::Instana.logger.warn('calling Tracer#add_span_processor after shutdown.')
+            return
+          end
+          @span_processors = @span_processors.dup.push(span_processor)
+        end
+      end
+
+      # This method serves as the primary entry point for span creation. It initializes
+      # an Instana span, handles context, and manages sampling before returning the created span.
+      def internal_start_span(name, kind, attributes, links, start_timestamp, parent_context, instrumentation_scope) # rubocop:disable Metrics/ParameterLists
+        parent_span = OpenTelemetry::Trace.current_span(parent_context)
+        parent_span_context = parent_span.context if parent_span
+        if parent_span_context&.valid?
+          parent_span_id = parent_span_context.span_id
+          trace_id = parent_span_context.trace_id
+          span_id = @id_generator.generate_span_id
+        end
+        trace_id ||= @id_generator.generate_trace_id
+
+        if OpenTelemetry::Common::Utilities.untraced?(parent_context)
+          span_id = parent_span_id || @id_generator.generate_span_id
+          return OpenTelemetry::Trace.non_recording_span(OpenTelemetry::Trace::SpanContext.new(trace_id: trace_id, span_id: span_id))
+        end
+
+        result = @sampler.should_sample?(trace_id: trace_id, parent_context: parent_context, links: links, name: name, kind: kind, attributes: attributes)
+        span_id ||= @id_generator.generate_span_id
+        if !@stopped && result.recording? && !@stopped
+          trace_flags = result.sampled? ? OpenTelemetry::Trace::TraceFlags::SAMPLED : OpenTelemetry::Trace::TraceFlags::DEFAULT
+          context = Instana::SpanContext.new(trace_id: trace_id, span_id: span_id, trace_flags: trace_flags, tracestate: result.tracestate)
+          attributes = attributes&.merge(result.attributes) || result.attributes.dup
+          Instana::Span.new(
+            name,
+            parent_span_context,
+            context,
+            parent_span,
+            kind,
+            parent_span_id,
+            @span_limits,
+            @span_processors,
+            attributes,
+            links,
+            start_timestamp,
+            @resource,
+            instrumentation_scope
+          )
+        else
+          Instana::Trace.non_recording_span(Instana::Trace::SpanContext.new(trace_id: trace_id, span_id: span_id, tracestate: result.tracestate)) # Todo add tracestate so that the trcing doesnot happen for this span # rubocop:disable Layout/LineLength
+        end
+      end
+
+      private
+
+      def sampler_from_environment(default_sampler)
+        case ENV['OTEL_TRACES_SAMPLER']
+        when 'always_on' then Samplers::ALWAYS_ON
+        when 'always_off' then Samplers::ALWAYS_OFF
+        when 'traceidratio' then Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACES_SAMPLER_ARG', 1.0)))
+        when 'parentbased_always_on' then Samplers.parent_based(root: Samplers::ALWAYS_ON)
+        when 'parentbased_always_off' then Samplers.parent_based(root: Samplers::ALWAYS_OFF)
+        when 'parentbased_traceidratio' then Samplers.parent_based(root: Samplers.trace_id_ratio_based(Float(ENV.fetch('OTEL_TRACES_SAMPLER_ARG', 1.0))))
+        else default_sampler
+        end
+      rescue StandardError => e
+        OpenTelemetry.handle_error(exception: e, message: "installing default sampler #{default_sampler.description}")
+        default_sampler
+      end
+
+      def timeout_timestamp
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end