ddtrace 1.11.1 → 1.12.0

data/lib/datadog/core/configuration.rb

@@ -208,7 +208,11 @@ module Datadog
       # Used internally to ensure a clean environment between test runs.
       def reset!
         safely_synchronize do |write_components|
-          @components.shutdown! if components?
+          if components?
+            @components.shutdown!
+            @temp_logger = nil # Reset to ensure instance and log level are reset for next run
+          end
+
           write_components.call(nil)
           configuration.reset!
         end

data/lib/datadog/core/remote/client/capabilities.rb

@@ -23,7 +23,7 @@ module Datadog
           private
 
           def register(settings)
-            if settings.appsec.enabled
+            if settings.respond_to?(:appsec) && settings.appsec.enabled
               register_capabilities(Datadog::AppSec::Remote.capabilities)
               register_products(Datadog::AppSec::Remote.products)
               register_receivers(Datadog::AppSec::Remote.receivers)

data/lib/datadog/core/telemetry/collector.rb

@@ -56,7 +56,8 @@ module Datadog
         def dependencies
           Gem.loaded_specs.collect do |name, loaded_gem|
             Datadog::Core::Telemetry::V1::Dependency.new(
-              name: name, version: loaded_gem.version.to_s, hash: loaded_gem.hash.to_s
+              # `hash` should be used when `version` is not available
+              name: name, version: loaded_gem.version.to_s, hash: nil
             )
           end
         end

data/lib/datadog/core/telemetry/v1/dependency.rb

@@ -17,9 +17,10 @@ module Datadog
 
           # @param name [String] Module name
           # @param version [String] Version of resolved module
-          # @param hash [String] Dependency hash
+          # @param hash [String] Dependency hash, in case `version` is not available
           def initialize(name:, version: nil, hash: nil)
             raise ArgumentError, ERROR_NIL_NAME_MESSAGE if name.nil?
+            raise ArgumentError, 'if both :version and :hash exist, use :version only' if version && hash
 
             @hash = hash
             @name = name

data/lib/datadog/kit/appsec/events.rb

@@ -14,38 +14,68 @@ module Datadog
         #
         # This method is experimental and may change in the future.
         #
-        # @param trace [TraceOperation] Trace to attach data to.
+        # @param trace [TraceOperation] Trace to attach data to. Defaults to
+        #   active trace.
+        # @param span [SpanOperation] Span to attach data to. Defaults to
+        #   active span on trace. Note that this should be a service entry span.
+        #   When AppSec is enabled, the expected span and trace are automatically
+        #   used as defaults.
         # @param user [Hash<Symbol, String>] User information to pass to
         #   Datadog::Kit::Identity.set_user. Must contain at least :id as key.
         # @param others [Hash<String || Symbol, String>] Additional free-form
         #   event information to attach to the trace.
-        def self.track_login_success(trace, user:, **others)
-          track(LOGIN_SUCCESS_EVENT, trace, **others)
+        def self.track_login_success(trace = nil, span = nil, user:, **others)
+          if (appsec_scope = Datadog::AppSec.active_scope)
+            trace = appsec_scope.trace
+            span = appsec_scope.service_entry_span
+          end
+
+          trace ||= Datadog::Tracing.active_trace
+          span ||= trace.active_span || Datadog::Tracing.active_span
+
+          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+
+          track(LOGIN_SUCCESS_EVENT, trace, span, **others)
 
           user_options = user.dup
           user_id = user_options.delete(:id)
 
           raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
 
-          Kit::Identity.set_user(trace, id: user_id, **user_options)
+          Kit::Identity.set_user(trace, span, id: user_id, **user_options)
         end
 
         # Attach login failure event information to the trace
         #
         # This method is experimental and may change in the future.
         #
-        # @param trace [TraceOperation] Trace to attach data to.
+        # @param trace [TraceOperation] Trace to attach data to. Defaults to
+        #   active trace.
+        # @param span [SpanOperation] Span to attach data to. Defaults to
+        #   active span on trace. Note that this should be a service entry span.
+        #   When AppSec is enabled, the expected span and trace are automatically
+        #   used as defaults.
         # @param user_id [String] User id that attempted login
         # @param user_exists [bool] Whether the user id that did a login attempt exists.
         # @param others [Hash<String || Symbol, String>] Additional free-form
         #   event information to attach to the trace.
-        def self.track_login_failure(trace, user_id:, user_exists:, **others)
-          track(LOGIN_FAILURE_EVENT, trace, **others)
+        def self.track_login_failure(trace = nil, span = nil, user_id:, user_exists:, **others)
+          if (appsec_scope = Datadog::AppSec.active_scope)
+            trace = appsec_scope.trace
+            span = appsec_scope.service_entry_span
+          end
+
+          trace ||= Datadog::Tracing.active_trace
+          span ||= trace.active_span || Datadog::Tracing.active_span
+
+          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+
+          track(LOGIN_FAILURE_EVENT, trace, span, **others)
 
           raise ArgumentError, 'user_id cannot be nil' if user_id.nil?
 
-          trace.set_tag('appsec.events.users.login.failure.usr.id', user_id)
-          trace.set_tag('appsec.events.users.login.failure.usr.exists', user_exists)
+          span.set_tag('appsec.events.users.login.failure.usr.id', user_id)
+          span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists)
         end
 
         # Attach custom event information to the trace
@@ -53,17 +83,32 @@ module Datadog
         # This method is experimental and may change in the future.
         #
         # @param event [String] Mandatory. Event code.
-        # @param trace [TraceOperation] Trace to attach data to.
+        # @param trace [TraceOperation] Trace to attach data to. Defaults to
+        #   active trace.
+        # @param span [SpanOperation] Span to attach data to. Defaults to
+        #   active span on trace. Note that this should be a service entry span.
+        #   When AppSec is enabled, the expected span and trace are automatically
+        #   used as defaults.
         # @param others [Hash<Symbol, String>] Additional free-form
         #   event information to attach to the trace. Key must not
         #   be :track.
-        def self.track(event, trace, **others)
-          trace.set_tag("appsec.events.#{event}.track", 'true')
+        def self.track(event, trace = nil, span = nil, **others)
+          if (appsec_scope = Datadog::AppSec.active_scope)
+            trace = appsec_scope.trace
+            span = appsec_scope.service_entry_span
+          end
+
+          trace ||= Datadog::Tracing.active_trace
+          span ||= trace.active_span || Datadog::Tracing.active_span
+
+          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+
+          span.set_tag("appsec.events.#{event}.track", 'true')
 
           others.each do |k, v|
             raise ArgumentError, 'key cannot be :track' if k.to_sym == :track
 
-            trace.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
+            span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
           end
 
           trace.keep!

data/lib/datadog/kit/identity.rb

@@ -8,7 +8,12 @@ module Datadog
     module Identity
       # Attach user information to the trace
       #
-      # @param trace [TraceOperation] Trace to attach data to.
+      # @param trace [TraceOperation] Trace to attach data to. Defaults to
+      #   active trace.
+      # @param span [SpanOperation] Span to attach data to. Defaults to
+      #   active span on trace. Note that this should be a service entry span.
+      #   When AppSec is enabled, the expected span and trace are automatically
+      #   used as defaults.
       # @param id [String] Mandatory. Username or client id extracted
       #   from the access token or Authorization header in the inbound request
       #   from outside the system.
@@ -29,7 +34,10 @@ module Datadog
       #
       # rubocop:disable Metrics/CyclomaticComplexity
       # rubocop:disable Metrics/PerceivedComplexity
-      def self.set_user(trace, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others)
+      # rubocop:disable Metrics/AbcSize
+      def self.set_user(
+        trace = nil, span = nil, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others
+      )
         raise ArgumentError, 'missing required key: :id' if id.nil?
 
         # enforce types
@@ -45,24 +53,35 @@ module Datadog
           raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
         end
 
+        if (appsec_scope = Datadog::AppSec.active_scope)
+          trace = appsec_scope.trace
+          span = appsec_scope.service_entry_span
+        end
+
+        trace ||= Datadog::Tracing.active_trace
+        span ||= trace.active_span || Datadog::Tracing.active_span
+
+        raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+
         # set tags once data is known consistent
 
-        trace.set_tag('usr.id', id)
-        trace.set_tag('usr.email', email)           unless email.nil?
-        trace.set_tag('usr.name', name)             unless name.nil?
-        trace.set_tag('usr.session_id', session_id) unless session_id.nil?
-        trace.set_tag('usr.role', role)             unless role.nil?
-        trace.set_tag('usr.scope', scope)           unless scope.nil?
+        span.set_tag('usr.id', id)
+        span.set_tag('usr.email', email)           unless email.nil?
+        span.set_tag('usr.name', name)             unless name.nil?
+        span.set_tag('usr.session_id', session_id) unless session_id.nil?
+        span.set_tag('usr.role', role)             unless role.nil?
+        span.set_tag('usr.scope', scope)           unless scope.nil?
 
         others.each do |k, v|
-          trace.set_tag("usr.#{k}", v) unless v.nil?
+          span.set_tag("usr.#{k}", v) unless v.nil?
         end
 
-        if Datadog.configuration.appsec.enabled
+        if appsec_scope
           user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
           ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
         end
       end
+      # rubocop:enable Metrics/AbcSize
       # rubocop:enable Metrics/PerceivedComplexity
       # rubocop:enable Metrics/CyclomaticComplexity
     end

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -20,6 +20,7 @@ module Datadog
           endpoint_collection_enabled:,
           gc_profiling_enabled:,
           allocation_counting_enabled:,
+          no_signals_workaround_enabled:,
           thread_context_collector: ThreadContext.new(
             recorder: recorder,
             max_frames: max_frames,
@@ -43,6 +44,7 @@ module Datadog
             gc_profiling_enabled,
             idle_sampling_helper,
             allocation_counting_enabled,
+            no_signals_workaround_enabled,
             dynamic_sampling_rate_enabled,
           )
           @worker_thread = nil

data/lib/datadog/profiling/component.rb

@@ -65,8 +65,6 @@ module Datadog
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
         if enable_new_profiler?(settings)
-          print_new_profiler_warnings
-
           recorder = Datadog::Profiling::StackRecorder.new(
             cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
             alloc_samples_enabled: false, # Always disabled for now -- work in progress
@@ -78,6 +76,7 @@ module Datadog
             endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
             gc_profiling_enabled: enable_gc_profiling?(settings),
             allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
+            no_signals_workaround_enabled: no_signals_workaround_enabled?(settings),
           )
         else
           recorder = build_profiler_old_recorder(settings)
@@ -141,19 +140,6 @@ module Datadog
         end
       end
 
-      private_class_method def self.print_new_profiler_warnings
-        return if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
-
-        # For more details on the issue, see the "BIG Issue" comment on `gvl_owner` function in
-        # `private_vm_api_access.c`.
-        Datadog.logger.warn(
-          'The new CPU Profiling 2.0 profiler has been force-enabled on a legacy Ruby version (< 2.6). This is not ' \
-          'recommended in production environments, as due to limitations in Ruby APIs, we suspect it may lead to crashes ' \
-          'in very rare situations. Please report any issues you run into to Datadog support or ' \
-          'via <https://github.com/datadog/dd-trace-rb/issues/new>!'
-        )
-      end
-
       private_class_method def self.enable_new_profiler?(settings)
         if settings.profiling.advanced.force_enable_legacy_profiler
           Datadog.logger.warn(
@@ -162,32 +148,71 @@ module Datadog
           return false
         end
 
-        return true if settings.profiling.advanced.force_enable_new_profiler
+        true
+      end
+
+      private_class_method def self.no_signals_workaround_enabled?(settings) # rubocop:disable Metrics/MethodLength
+        setting_value = settings.profiling.advanced.no_signals_workaround_enabled
+        legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?('2.3.', '2.4.', '2.5.')
+
+        unless [true, false, :auto].include?(setting_value)
+          Datadog.logger.error(
+            "Ignoring invalid value for profiling no_signals_workaround_enabled setting: #{setting_value.inspect}. " \
+            'Valid options are `true`, `false` or (default) `:auto`.'
+          )
+
+          setting_value = :auto
+        end
+
+        if setting_value == false
+          if legacy_ruby_that_should_use_workaround
+            Datadog.logger.warn(
+              'The profiling "no signals" workaround has been disabled via configuration on a legacy Ruby version ' \
+              '(< 2.6). This is not recommended ' \
+              'in production environments, as due to limitations in Ruby APIs, we suspect it may lead to crashes ' \
+              'in very rare situations. Please report any issues you run into to Datadog support or ' \
+              'via <https://github.com/datadog/dd-trace-rb/issues/new>!'
+            )
+          else
+            Datadog.logger.warn('Profiling "no signals" workaround disabled via configuration')
+          end
+
+          return false
+        end
+
+        if setting_value == true
+          Datadog.logger.warn(
+            'Profiling "no signals" workaround enabled via configuration. Profiling data will have lower quality.'
+          )
+
+          return true
+        end
+
+        # Setting is in auto mode. Let's probe to see if we should enable it:
 
-        return false if RUBY_VERSION.start_with?('2.3.', '2.4.', '2.5.')
+        # We don't warn users in this situation because "upgrade your Ruby" is not a great warning
+        return true if legacy_ruby_that_should_use_workaround
 
         if Gem.loaded_specs['mysql2'] && incompatible_libmysqlclient_version?(settings)
           Datadog.logger.warn(
-            'Falling back to legacy profiler because an incompatible version of the mysql2 gem is installed. ' \
-            'Older versions of libmysqlclient (the C ' \
-            'library used by the mysql2 gem) have a bug in their signal handling code that the new profiler can trigger. ' \
-            'This bug (https://bugs.mysql.com/bug.php?id=83109) is fixed in libmysqlclient versions 8.0.0 and above. '
+            'Enabling the profiling "no signals" workaround because an incompatible version of the mysql2 gem is ' \
+            'installed. Profiling data will have lower quality.' \
+            'To fix this, upgrade the libmysqlclient in your OS image to version 8.0.0 or above.'
           )
-          return false
+          return true
         end
 
         if Gem.loaded_specs['rugged']
           Datadog.logger.warn(
-            'Falling back to legacy profiler because rugged gem is installed. Some operations on this gem are ' \
-            'currently incompatible with the new CPU Profiling 2.0 profiler, as detailed in ' \
-            '<https://github.com/datadog/dd-trace-rb/issues/2721>. If you still want to try out the new profiler, you ' \
-            'can force-enable it by using the `DD_PROFILING_FORCE_ENABLE_NEW` environment variable or the ' \
-            '`c.profiling.advanced.force_enable_new_profiler` setting.'
+            'Enabling the profiling "no signals" workaround because the rugged gem is installed. ' \
+            'This is needed because some operations on this gem are currently incompatible with the normal working mode ' \
+            'of the profiler, as detailed in <https://github.com/datadog/dd-trace-rb/issues/2721>. ' \
+            'Profiling data will have lower quality.'
           )
-          return false
+          return true
         end
 
-        true
+        false
       end
 
       # Versions of libmysqlclient prior to 8.0.0 are known to have buggy handling of system call interruptions.

data/lib/datadog/tracing/buffer.rb

@@ -1,4 +1,3 @@
-require_relative '../core'
 require_relative '../core/environment/ext'
 require_relative '../core/buffer/thread_safe'
 require_relative '../core/buffer/cruby'

data/lib/datadog/tracing/contrib/active_support/configuration/settings.rb

@@ -26,7 +26,15 @@ module Datadog
               o.lazy
             end
 
-            option :cache_service, default: Ext::SERVICE_CACHE
+            option :cache_service do |o|
+              o.default do
+                Contrib::SpanAttributeSchema.fetch_service_name(
+                  '',
+                  Ext::SERVICE_CACHE
+                )
+              end
+              o.lazy
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/aws/ext.rb

@@ -18,7 +18,17 @@ module Datadog
           TAG_OPERATION = 'aws.operation'.freeze
           TAG_OPERATION_COMMAND = 'command'.freeze
           TAG_PATH = 'path'.freeze
-          TAG_REGION = 'aws.region'.freeze
+          TAG_AWS_REGION = 'aws.region'.freeze
+          TAG_REGION = 'region'.freeze
+          TAG_AWS_SERVICE = 'aws_service'.freeze
+          TAG_AWS_ACCOUNT = 'aws_account'.freeze
+          TAG_QUEUE_NAME = 'queuename'.freeze
+          TAG_TOPIC_NAME = 'topicname'.freeze
+          TAG_TABLE_NAME = 'tablename'.freeze
+          TAG_STREAM_NAME = 'streamname'.freeze
+          TAG_RULE_NAME = 'rulename'.freeze
+          TAG_STATE_MACHINE_NAME = 'statemachinename'.freeze
+          TAG_BUCKET_NAME = 'bucketname'.freeze
         end
       end
     end

data/lib/datadog/tracing/contrib/aws/instrumentation.rb

@@ -33,6 +33,12 @@ module Datadog
             span.span_type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
             span.name = Ext::SPAN_COMMAND
             span.resource = context.safely(:resource)
+            aws_service = span.resource.split('.')[0]
+            span.set_tag(Ext::TAG_AWS_SERVICE, aws_service)
+            params = context.safely(:params)
+            if (handler = Datadog::Tracing::Contrib::Aws::SERVICE_HANDLERS[aws_service])
+              handler.add_tags(span, params)
+            end
 
             span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
 
@@ -55,6 +61,7 @@ module Datadog
             span.set_tag(Ext::TAG_AGENT, Ext::TAG_DEFAULT_AGENT)
             span.set_tag(Ext::TAG_OPERATION, context.safely(:operation))
             span.set_tag(Ext::TAG_REGION, context.safely(:region))
+            span.set_tag(Ext::TAG_AWS_REGION, context.safely(:region))
             span.set_tag(Ext::TAG_PATH, context.safely(:path))
             span.set_tag(Ext::TAG_HOST, context.safely(:host))
             span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, context.safely(:http_method))

data/lib/datadog/tracing/contrib/aws/parsed_context.rb

@@ -20,6 +20,10 @@ module Datadog
             context.operation_name
           end
 
+          def params
+            context.params
+          end
+
           def status_code
             context.http_response.status_code
           end

data/lib/datadog/tracing/contrib/aws/service/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # Base class for all AWS service-specific tag handlers.
+          class Base
+            def add_tags(span, params); end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/dynamodb.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # DynamoDB tag handlers.
+          class DynamoDB < Base
+            def add_tags(span, params)
+              table_name = params[:table_name]
+              span.set_tag(Aws::Ext::TAG_TABLE_NAME, table_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/eventbridge.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # EventBridge tag handlers.
+          class EventBridge < Base
+            def add_tags(span, params)
+              rule_name = params[:name] || params[:rule]
+              span.set_tag(Aws::Ext::TAG_RULE_NAME, rule_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/kinesis.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # Kinesis tag handlers.
+          class Kinesis < Base
+            def add_tags(span, params)
+              stream_arn = params[:stream_arn]
+              stream_name = params[:stream_name]
+
+              if stream_arn
+                # example stream_arn: arn:aws:kinesis:us-east-1:123456789012:stream/my-stream
+                parts = stream_arn.split(':')
+                stream_name = parts[-1].split('/')[-1]
+                aws_account = parts[-2]
+                span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, aws_account)
+              end
+
+              span.set_tag(Aws::Ext::TAG_STREAM_NAME, stream_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/s3.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # S3 tag handlers.
+          class S3 < Base
+            def add_tags(span, params)
+              bucket_name = params[:bucket]
+              span.set_tag(Aws::Ext::TAG_BUCKET_NAME, bucket_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/sns.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # SNS tag handlers.
+          class SNS < Base
+            def add_tags(span, params)
+              topic_arn = params[:topic_arn]
+              topic_name = params[:name]
+              if topic_arn
+                # example topic_arn: arn:aws:sns:us-west-2:123456789012:my-topic-name
+                parts = topic_arn.split(':')
+                topic_name = parts[-1]
+                aws_account = parts[-2]
+                span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, aws_account)
+              end
+              span.set_tag(Aws::Ext::TAG_TOPIC_NAME, topic_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/sqs.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # SQS tag handlers.
+          class SQS < Base
+            def add_tags(span, params)
+              queue_url = params[:queue_url]
+              queue_name = params[:queue_name]
+              if queue_url
+                _, _, _, aws_account, queue_name = queue_url.split('/')
+                span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, aws_account)
+              end
+              span.set_tag(Aws::Ext::TAG_QUEUE_NAME, queue_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/stepfunctions.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # States tag handlers.
+          class States < Base
+            def add_tags(span, params)
+              state_machine_name = params[:name]
+              state_machine_arn = params[:state_machine_arn]
+              execution_arn = params[:execution_arn]
+              state_machine_account_id = ''
+
+              if execution_arn
+                # 'arn:aws:states:us-east-1:123456789012:execution:example-state-machine:example-execution'
+                parts = execution_arn.split(':')
+                state_machine_name = parts[-2]
+                state_machine_account_id = parts[4]
+              end
+
+              if state_machine_arn
+                # example statemachinearn: arn:aws:states:us-east-1:123456789012:stateMachine:MyStateMachine
+                parts = state_machine_arn.split(':')
+                state_machine_name ||= parts[-1]
+                state_machine_account_id = parts[-3]
+              end
+              span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, state_machine_account_id)
+              span.set_tag(Aws::Ext::TAG_STATE_MACHINE_NAME, state_machine_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end