instana 1.217.0 → 2.0.0

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

data/lib/instana/trace.rb

@@ -0,0 +1,74 @@
+# (c) Copyright IBM Corp. 2025
+require 'opentelemetry/context'
+module Instana
+  # The Trace API allows recording a set of events, triggered as a result of a
+  # single logical operation, consolidated across various components of an
+  # application.
+  module Trace
+    include OpenTelemetry::Trace
+
+    module_function
+
+    ID_RANGE = -2**63..2**63 - 1
+
+    # Generates a valid trace identifier
+
+    def generate_trace_id(size = 1)
+      Array.new(size) { rand(ID_RANGE) }
+           .pack('q>*')
+           .unpack1('H*')
+    end
+
+    # Generates a valid span identifier
+    #
+    def generate_span_id(size = 1)
+      Array.new(size) { rand(ID_RANGE) }
+           .pack('q>*')
+           .unpack1('H*')
+    end
+
+    # Returns the current span from the current or provided context
+    #
+    # @param [optional Context] context The context to lookup the current
+    #   {Span} from. Defaults to Context.current
+    def current_span(context = nil)
+      context ||= OpenTelemetry::Context.current
+      context.value(CURRENT_SPAN_KEY) || nil
+    end
+
+    # Returns a context containing the span, derived from the optional parent
+    # context, or the current context if one was not provided.
+    #
+    # @param [optional Context] context The context to use as the parent for
+    #   the returned context
+    def context_with_span(span, parent_context:  OpenTelemetry::Context.current)
+      parent_context.set_value(CURRENT_SPAN_KEY, span)
+    end
+
+    # Activates/deactivates the Span within the current Context, which makes the "current span"
+    # available implicitly.
+    #
+    # On exit, the Span that was active before calling this method will be reactivated.
+    #
+    # @param [Span] span the span to activate
+    # @yield [span, context] yields span and a context containing the span to the block.
+    def with_span(span)
+      OpenTelemetry::Context.with_value(CURRENT_SPAN_KEY, span) { |c, s| yield s, c }
+    end
+
+    # Wraps a SpanContext with an object implementing the Span interface. This is done in order
+    # to expose a SpanContext as a Span in operations such as in-process Span propagation.
+    #
+    # @param [SpanContext] span_context SpanContext to be wrapped
+    #
+    # @return [Span]
+    def non_recording_span(span_context)
+      Span.new(span_context: span_context)
+    end
+  end
+end
+
+require 'instana/trace/span_context'
+require 'instana/trace/span_kind'
+require 'instana/trace/span'
+require 'instana/trace/tracer'

data/lib/instana/util.rb

@@ -170,6 +170,17 @@ module Instana
         return '' unless given.match(/\A[a-z\d]{16,32}\z/i)
         given
       end
+
+      def timeout_timestamp
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def maybe_timeout(timeout, start_time)
+        return nil if timeout.nil?
+
+        timeout -= (timeout_timestamp - start_time)
+        timeout.positive? ? timeout : 0
+      end
     end
   end
 end

data/lib/instana/version.rb

@@ -2,6 +2,6 @@
 # (c) Copyright Instana Inc. 2016
 
 module Instana
-  VERSION = "1.217.0"
+  VERSION = "2.0.0"
   VERSION_FULL = "instana-#{VERSION}"
 end

data/test/frameworks/sinatra_test.rb

@@ -7,6 +7,7 @@ require 'rack/test'
 class SinatraTest < Minitest::Test
   include Rack::Test::Methods
   APP = Rack::Builder.parse_file('test/support/apps/sinatra/config.ru')
+
   sinatra_version = Gem::Specification.find_by_name('sinatra').version
   if sinatra_version < Gem::Version.new('4.0.0')
     APP = APP.first
@@ -18,8 +19,8 @@ class SinatraTest < Minitest::Test
 
   def test_basic_get
     clear_all!
-
     r = get '/'
+
     assert last_response.ok?
 
 

data/test/instrumentation/aws_test.rb

@@ -17,7 +17,7 @@ class AwsTest < Minitest::Test
     )
 
     assert_raises Aws::DynamoDB::Errors::ResourceNotFoundException do
-      Instana::Tracer.start_or_continue_trace(:dynamo_test, {}) do
+      Instana.tracer.in_span(:dynamo_test, attributes: {}) do
         dynamo.get_item(
           table_name: 'sample_table',
           key: { s: 'sample_item' }
@@ -45,7 +45,7 @@ class AwsTest < Minitest::Test
     )
 
     assert_raises Aws::S3::Errors::NoSuchBucket do
-      Instana::Tracer.start_or_continue_trace(:s3_test, {}) do
+      Instana.tracer.in_span(:s3_test, attributes: {}) do
         s3_client.get_object(
           bucket: 'sample-bucket',
           key: 'sample_key'
@@ -73,7 +73,7 @@ class AwsTest < Minitest::Test
     )
 
     assert_raises Aws::SNS::Errors::NotFound do
-      Instana::Tracer.start_or_continue_trace(:sns_test, {}) do
+      Instana.tracer.in_span(:sns_test, attributes: {}) do
         sns.publish(
           topic_arn: 'topic:arn',
           target_arn: 'target:arn',
@@ -104,7 +104,7 @@ class AwsTest < Minitest::Test
       endpoint: "http://localhost:9911"
     )
 
-    Instana::Tracer.start_or_continue_trace(:sns_test, {}) do
+    Instana.tracer.in_span(:sns_test, attributes: {}) do
       sns.list_subscriptions
     end
 
@@ -127,7 +127,7 @@ class AwsTest < Minitest::Test
     create_response = nil
     get_url_response = nil
 
-    Instana::Tracer.start_or_continue_trace(:sqs_test, {}) do
+    Instana.tracer.in_span(:sqs_test, attributes: {}) do
       create_response = sqs.create_queue(queue_name: 'test')
       get_url_response = sqs.get_queue_url(queue_name: 'test')
       sqs.send_message(queue_url: create_response.queue_url, message_body: 'Sample')
@@ -177,7 +177,7 @@ class AwsTest < Minitest::Test
       secret_access_key: "test"
     )
 
-    Instana::Tracer.start_or_continue_trace(:lambda_test, {}) do
+    Instana.tracer.in_span(:lambda_test, attributes: {}) do
       lambda.invoke(
         function_name: 'Test',
         invocation_type: 'Event',
@@ -216,7 +216,7 @@ class AwsTest < Minitest::Test
     )
 
     assert_raises(RuntimeError) do
-      Instana::Tracer.start_or_continue_trace(:lambda_test, {}) do
+      Instana.tracer.in_span(:lambda_test, attributes: {}) do
         lambda.invoke(
           function_name: 'Test',
           invocation_type: 'Event',