datadog 2.2.0 → 2.4.0

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

@@ -114,7 +114,10 @@ module Datadog
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
                 if sql
-                  propagation_mode = Contrib::Propagation::SqlComment::Mode.new(comment_propagation)
+                  propagation_mode = Contrib::Propagation::SqlComment::Mode.new(
+                    comment_propagation,
+                    datadog_configuration[:append_comment]
+                  )
                   Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
                   propagated_sql_statement = Contrib::Propagation::SqlComment.prepend_comment(
                     sql,

data/lib/datadog/tracing/contrib/presto/patcher.rb

@@ -13,22 +13,10 @@ module Datadog
         module Patcher
           include Contrib::Patcher
 
-          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
-
           module_function
 
-          def patched?
-            PATCH_ONLY_ONCE.ran?
-          end
-
           def patch
-            PATCH_ONLY_ONCE.run do
-              begin
-                ::Presto::Client::Client.include(Instrumentation::Client)
-              rescue StandardError => e
-                Datadog.logger.error("Unable to apply Presto integration: #{e}")
-              end
-            end
+            ::Presto::Client::Client.include(Instrumentation::Client)
           end
         end
       end

data/lib/datadog/tracing/contrib/propagation/sql_comment/ext.rb

@@ -20,10 +20,38 @@ module Datadog
             # The value should be `true` when `full` mode
             TAG_DBM_TRACE_INJECTED = '_dd.dbm_trace_injected'
 
+            # Database service/sql span service (i.e. the service executing the actual query)
+            #
+            # If fake services are disabled:
+            #   This value will be the same as the parent service
+            #
+            # If fake services are enabled:
+            #   This value is NOT the same as the parent service
+            #
+            # This should NOT be overridden by peer.service.
             KEY_DATABASE_SERVICE = 'dddbs'
+
+            # The global service environment (e.g. DD_ENV)
             KEY_ENVIRONMENT = 'dde'
+
+            # The global service name (e.g. DD_SERVICE)
             KEY_PARENT_SERVICE = 'ddps'
+
+            # The global service version (e.g. DD_VERSION)
             KEY_VERSION = 'ddpv'
+
+            # The hostname of the database server, as provided to the database client upon instantiation.
+            # @see Datadog::Tracing::Metadata::Ext::TAG_PEER_HOSTNAME
+            KEY_HOSTNAME = 'ddh'
+
+            # @see Datadog::Tracing::Contrib::Ext::DB::TAG_INSTANCE
+            KEY_DB_NAME = 'dddb'
+
+            # Users can use this attribute to specify the identity of the dependency/database they are connecting to.
+            # We should grab this attribute only if the user is EXPLICITLY specifying it.
+            # @see Datadog::Tracing::Metadata::Ext::TAG_PEER_SERVICE
+            KEY_PEER_SERVICE = 'ddprs'
+
             KEY_TRACEPARENT = 'traceparent'
           end
         end

data/lib/datadog/tracing/contrib/propagation/sql_comment/mode.rb

@@ -8,7 +8,7 @@ module Datadog
       module Propagation
         # Implements sql comment propagation related contracts.
         module SqlComment
-          Mode = Struct.new(:mode) do
+          Mode = Struct.new(:mode, :append) do
             def enabled?
               service? || full?
             end
@@ -20,6 +20,10 @@ module Datadog
             def full?
               mode == Ext::FULL
             end
+
+            def append?
+              append
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/propagation/sql_comment.rb

@@ -22,16 +22,28 @@ module Datadog
           def self.prepend_comment(sql, span_op, trace_op, mode)
             return sql unless mode.enabled?
 
+            config = Datadog.configuration
+
+            parent_service = config.service
+            peer_service = span_op.get_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE)
+
             tags = {
-              Ext::KEY_DATABASE_SERVICE => span_op.get_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE) || span_op.service,
-              Ext::KEY_ENVIRONMENT => datadog_configuration.env,
-              Ext::KEY_PARENT_SERVICE => datadog_configuration.service,
-              Ext::KEY_VERSION => datadog_configuration.version
+              Ext::KEY_ENVIRONMENT => config.env,
+              Ext::KEY_PARENT_SERVICE => parent_service,
+              Ext::KEY_VERSION => config.version,
+              Ext::KEY_HOSTNAME => span_op.get_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME),
+              Ext::KEY_DB_NAME => span_op.get_tag(Contrib::Ext::DB::TAG_INSTANCE),
+              Ext::KEY_PEER_SERVICE => peer_service,
             }
 
+            db_service = peer_service || span_op.service
+            if parent_service != db_service # Only set if it's different from parent_service; otherwise it's redundant
+              tags[Ext::KEY_DATABASE_SERVICE] = db_service
+            end
+
             if mode.full?
               # When tracing is disabled, trace_operation is a dummy object that does not contain data to build traceparent
-              if datadog_configuration.tracing.enabled
+              if config.tracing.enabled
                 tags[Ext::KEY_TRACEPARENT] =
                   Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_traceparent, trace_op.to_digest)
               else
@@ -42,11 +54,11 @@ module Datadog
               end
             end
 
-            "#{Comment.new(tags)} #{sql}"
-          end
-
-          def self.datadog_configuration
-            Datadog.configuration
+            if mode.append?
+              "#{sql} #{Comment.new(tags)}"
+            else
+              "#{Comment.new(tags)} #{sql}"
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/rack/middlewares.rb

@@ -138,6 +138,29 @@ module Datadog
             request_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
             request_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
+            if status != 404 && (last_route = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE))
+              last_script_name = trace.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH) || ''
+
+              # If the last_script_name is empty but the env['SCRIPT_NAME'] is NOT empty
+              # then the current rack request was not routed and must be accounted for
+              # which only happens in pure nested rack requests i.e /rack/rack/hello/world
+              #
+              # To account for the unaccounted nested rack requests of /rack/hello/world,
+              # we use 'PATH_INFO knowing that rack cannot have named parameters
+              if last_script_name == '' && env['SCRIPT_NAME'] && env['SCRIPT_NAME'] != ''
+                last_script_name = last_route
+                last_route = env['PATH_INFO']
+              end
+
+              # Clear the route and route path tags from the request trace to avoid possibility of misplacement
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE)
+              trace.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+
+              # Ensure tags are placed in rack.request span as desired
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, last_script_name + last_route)
+              request_span.clear_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH)
+            end
+
             # Set analytics sample rate
             if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
               Contrib::Analytics.set_sample_rate(request_span, configuration[:analytics_sample_rate])
@@ -195,6 +218,10 @@ module Datadog
               request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
             end
 
+            if request_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE).nil? && status != 404
+              request_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, env['PATH_INFO'])
+            end
+
             HeaderTagging.tag_request_headers(request_span, request_header_collection, configuration)
             HeaderTagging.tag_response_headers(request_span, headers, configuration) if headers
 

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -4,6 +4,7 @@ require_relative '../../metadata/ext'
 require_relative '../analytics'
 require_relative 'ext'
 require_relative '../ext'
+require_relative '../../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -45,6 +46,9 @@ module Datadog
               span.set_tag Ext::TAG_RAW_COMMAND, raw_command
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+            rescue StandardError => e
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
             end
 
             private

data/lib/datadog/tracing/contrib/sinatra/tracer.rb

@@ -69,6 +69,10 @@ module Datadog
 
                 trace.resource = span.resource
 
+                _, path = env['sinatra.route'].split(' ', 2)
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, path)
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env['SCRIPT_NAME'])
+
                 sinatra_request_span = Sinatra::Env.datadog_span(env)
 
                 sinatra_request_span.resource = span.resource

data/lib/datadog/tracing/contrib/stripe/request.rb

@@ -47,8 +47,9 @@ module Datadog
 
             # Measure service stats
             Contrib::Analytics.set_measured(span)
-
-            span.set_tag(Ext::TAG_REQUEST_ID, event.request_id)
+            # `5.38.0` Add request_id to RequestEndEvent
+            # https://github.com/stripe/stripe-ruby/blob/master/CHANGELOG.md#5380---2021-08-10
+            span.set_tag(Ext::TAG_REQUEST_ID, event.request_id) if event.respond_to?(:request_id)
             span.set_tag(Ext::TAG_REQUEST_HTTP_STATUS, event.http_status.to_s)
             span.set_tag(Ext::TAG_REQUEST_METHOD, event.method)
             span.set_tag(Ext::TAG_REQUEST_PATH, event.path)

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

@@ -46,6 +46,11 @@ module Datadog
               o.default Contrib::Propagation::SqlComment::Ext::DISABLED
             end
 
+            option :append_comment do |o|
+              o.type :bool
+              o.default false
+            end
+
             option :peer_service do |o|
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE

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

@@ -49,13 +49,16 @@ module Datadog
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
+                span.set_tag(Contrib::Ext::DB::TAG_INSTANCE, connection_options[:database])
                 span.set_tag(Ext::TAG_DB_NAME, connection_options[:database])
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, connection_options[:host])
                 span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, connection_options[:port])
 
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
 
-                propagation_mode = Contrib::Propagation::SqlComment::Mode.new(comment_propagation)
+                propagation_mode = Contrib::Propagation::SqlComment::Mode.new(
+                  comment_propagation, datadog_configuration[:append_comment]
+                )
 
                 Contrib::Propagation::SqlComment.annotate!(span, propagation_mode)
                 sql = Contrib::Propagation::SqlComment.prepend_comment(

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -14,8 +14,8 @@ module Datadog
 
         def self.collect_and_log!(responses: nil)
           if log?
-            env_data = EnvironmentCollector.collect_config!
-            log_configuration!('TRACING', env_data.to_json)
+            log_configuration!('TRACING', EnvironmentCollector.collect_config!.to_json)
+            log_debug!('TRACING INTEGRATIONS', EnvironmentCollector.collect_integrations_settings!.to_json)
 
             if responses
               err_data = EnvironmentCollector.collect_errors!(responses)
@@ -40,7 +40,6 @@ module Datadog
               sampling_rules: sampling_rules,
               integrations_loaded: integrations_loaded,
               partial_flushing_enabled: partial_flushing_enabled,
-              **instrumented_integrations_settings
             }
           end
 
@@ -128,6 +127,18 @@ module Datadog
             !!Datadog.configuration.tracing.partial_flush.enabled
           end
 
+          def collect_integrations_settings!
+            instrumented_integrations.each_with_object({}) do |(name, integration), result|
+              integration.configuration.to_h.each do |setting, value|
+                next if setting == :tracer # Skip internal objects
+
+                # Convert value to a string to avoid custom #to_json
+                # handlers possibly causing errors.
+                result[:"#{name}_#{setting}"] = value.to_s
+              end
+            end
+          end
+
           private
 
           def instrumented_integrations
@@ -139,19 +150,6 @@ module Datadog
 
             Datadog.configuration.tracing.instrumented_integrations
           end
-
-          # Capture all active integration settings into "integrationName_settingName: value" entries.
-          def instrumented_integrations_settings
-            instrumented_integrations.flat_map do |name, integration|
-              integration.configuration.to_h.flat_map do |setting, value|
-                next [] if setting == :tracer # Skip internal Ruby objects
-
-                # Convert value to a string to avoid custom #to_json
-                # handlers possibly causing errors.
-                [[:"integration_#{name}_#{setting}", value.to_s]]
-              end
-            end.to_h
-          end
         end
       end
     end

data/lib/datadog/tracing/distributed/propagation.rb

@@ -3,6 +3,7 @@
 require_relative '../configuration/ext'
 require_relative '../trace_digest'
 require_relative '../trace_operation'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -43,6 +44,7 @@ module Datadog
         # DEV-2.0: if needed.
         # DEV-2.0: Ideally, we'd have a separate stream to report tracer errors and never
         # DEV-2.0: touch the active span.
+        # DEV-3.0: Sample trace here instead of when generating digest.
         #
         # @param digest [TraceDigest]
         # @param data [Hash]
@@ -72,6 +74,10 @@ module Datadog
             ::Datadog.logger.error(
               "Error injecting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
             )
+            ::Datadog::Core::Telemetry::Logger.report(
+              e,
+              description: "Error injecting distributed trace data with #{propagator.class.name}"
+            )
           end
 
           result
@@ -127,6 +133,7 @@ module Datadog
               )
             end
           rescue => e
+            # TODO: Not to report Telemetry logs for now
             ::Datadog.logger.error(
               "Error extracting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
             )

data/lib/datadog/tracing/metadata/errors.rb

@@ -10,8 +10,16 @@ module Datadog
       # Adds error tagging behavior
       # @public_api
       module Errors
-        # Mark the span with the given error.
         def set_error(e)
+          Datadog::Core.log_deprecation do
+            'Errors.set_error(..) is deprecated. ' \
+            'Use Errors.set_error_tags(..) instead.'
+          end
+          set_error_tags(e)
+        end
+
+        # Mark the span with the given error.
+        def set_error_tags(e)
           e = Core::Error.build_from(e)
 
           set_tag(Ext::Errors::TAG_TYPE, e.type) unless e.type.empty?

data/lib/datadog/tracing/metadata/ext.rb

@@ -14,6 +14,10 @@ module Datadog
         # Type of operation being performed (e.g. )
         TAG_OPERATION = 'operation'
         # Hostname of external service interacted with
+        #
+        # This tag also doesn't strictly need to be a “hostname”. It can be a raw IP address and in some cases it
+        # can even be a unix domain socket (i.e. postgres client setting host=/var/run/postgres).
+        # It should be whatever the client uses to point at the server it’s trying to talk to.
         TAG_PEER_HOSTNAME = 'peer.hostname'
         # Name of external service that performed the work
         TAG_PEER_SERVICE = 'peer.service'
@@ -83,6 +87,8 @@ module Datadog
           TAG_STATUS_CODE = 'http.status_code'
           TAG_USER_AGENT = 'http.useragent'
           TAG_URL = 'http.url'
+          TAG_ROUTE = 'http.route'
+          TAG_ROUTE_PATH = 'http.route.path'
           TYPE_INBOUND = AppTypes::TYPE_WEB.freeze
           TYPE_OUTBOUND = 'http'
           TYPE_PROXY = 'proxy'

data/lib/datadog/tracing/pipeline/span_filter.rb

@@ -10,8 +10,8 @@ module Datadog
       # This processor executes the configured `operation` for each {Datadog::Tracing::Span}
       # in a {Datadog::Tracing::TraceSegment}.
       #
-      # If `operation` returns a truthy value for a span, that span is kept,
-      # otherwise the span is removed from the trace.
+      # If `operation` returns a truthy value for a span, that span is dropped,
+      # otherwise the span is kept.
       #
       # @public_api
       class SpanFilter < SpanProcessor

data/lib/datadog/tracing/remote.rb

@@ -13,7 +13,10 @@ module Datadog
         PRODUCT = 'APM_TRACING'
 
         CAPABILITIES = [
-          1 << 29 # APM_TRACING_SAMPLE_RULES: Dynamic trace sampling rules configuration
+          1 << 12, # APM_TRACING_SAMPLE_RATE: Dynamic trace sampling rate configuration
+          1 << 13, # APM_TRACING_LOGS_INJECTION: Dynamic trace logs injection configuration
+          1 << 14, # APM_TRACING_HTTP_HEADER_TAGS: Dynamic trace HTTP header tags configuration
+          1 << 29, # APM_TRACING_SAMPLE_RULES: Dynamic trace sampling rules configuration
         ].freeze
 
         def products
@@ -45,7 +48,7 @@ module Datadog
           content.errored("#{e.class.name} #{e.message}: #{Array(e.backtrace).join("\n")}")
         end
 
-        def receivers
+        def receivers(_telemetry)
           receiver do |repository, _changes|
             # DEV: Filter our by product. Given it will be very common
             # DEV: we can filter this out before we receive the data in this method.

data/lib/datadog/tracing/sampling/matcher.rb

@@ -28,7 +28,7 @@ module Datadog
         # @return [#match?(String)]
         def self.glob_to_regex(glob)
           # Optimization for match-all case
-          return MATCH_ALL if glob == MATCH_ALL_PATTERN
+          return MATCH_ALL if /\A\*+\z/.match?(glob)
 
           # Ensure no undesired characters are treated as regex.
           glob = Regexp.quote(glob)
@@ -100,6 +100,11 @@ module Datadog
           @tags.all? do |name, matcher|
             tag = trace.get_tag(name)
 
+            # Floats: Matching floating point values with a non-zero decimal part is not supported.
+            # For floating point values with a non-zero decimal part, any all * pattern always returns true.
+            # Other patterns always return false.
+            return false if tag.is_a?(Float) && tag.truncate != tag && matcher != MATCH_ALL
+
             # Format metrics as strings, to allow for partial number matching (/4.*/ matching '400', '404', etc.).
             # Because metrics are floats, we use the '%g' format specifier to avoid trailing zeros, which
             # can affect exact string matching (e.g. '400' matching '400.0').

data/lib/datadog/tracing/sampling/rate_sampler.rb

@@ -20,7 +20,7 @@ module Datadog
           super()
 
           unless sample_rate >= 0.0 && sample_rate <= 1.0
-            Datadog.logger.error('sample rate is not between 0 and 1, falling back to 1')
+            Datadog.logger.warn('sample rate is not between 0 and 1, falling back to 1')
             sample_rate = 1.0
           end
 

data/lib/datadog/tracing/sampling/rule.rb

@@ -2,6 +2,7 @@
 
 require_relative 'matcher'
 require_relative 'rate_sampler'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -35,6 +36,7 @@ module Datadog
           Datadog.logger.error(
             "Matcher failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
+          Datadog::Core::Telemetry::Logger.report(e, description: 'Matcher failed')
           nil
         end
 

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'ext'
-require_relative 'rate_limiter'
+require_relative '../../core/rate_limiter'
 require_relative 'rule'
+require_relative '../../core/telemetry/logger'
 
 module Datadog
   module Tracing
@@ -32,9 +33,9 @@ module Datadog
           @rate_limiter = if rate_limiter
                             rate_limiter
                           elsif rate_limit
-                            TokenBucket.new(rate_limit)
+                            Core::TokenBucket.new(rate_limit)
                           else
-                            UnlimitedLimiter.new
+                            Core::UnlimitedLimiter.new
                           end
 
           @default_sampler = if default_sampler
@@ -80,9 +81,10 @@ module Datadog
 
           new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
         rescue => e
-          Datadog.logger.error do
+          Datadog.logger.warn do
             "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
           end
+
           nil
         end
 
@@ -121,7 +123,7 @@ module Datadog
 
           return false unless sampled
 
-          rate_limiter.allow?(1).tap do |allowed|
+          rate_limiter.allow?.tap do |allowed|
             set_priority(trace, allowed)
             set_limiter_metrics(trace, rate_limiter.effective_rate)
 
@@ -140,6 +142,8 @@ module Datadog
           Datadog.logger.error(
             "Rule sampling failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
           )
+          Datadog::Core::Telemetry::Logger.report(e, description: 'Rule sampling failed')
+
           yield(trace)
         end
 

data/lib/datadog/tracing/sampling/span/ext.rb

@@ -9,7 +9,7 @@ module Datadog
           # Accept all spans (100% retention).
           DEFAULT_SAMPLE_RATE = 1.0
           # Unlimited.
-          # @see Datadog::Tracing::Sampling::TokenBucket
+          # @see Datadog::Core::TokenBucket
           DEFAULT_MAX_PER_SECOND = -1
 
           # Sampling decision method used to come to the sampling decision for this span

data/lib/datadog/tracing/sampling/span/rule.rb

@@ -30,7 +30,7 @@ module Datadog
             @rate_limit = rate_limit
 
             @sampler = Sampling::RateSampler.new(sample_rate)
-            @rate_limiter = Sampling::TokenBucket.new(rate_limit)
+            @rate_limiter = Core::TokenBucket.new(rate_limit)
           end
 
           # This method should only be invoked for spans that are part
@@ -54,7 +54,7 @@ module Datadog
           def sample!(trace_op, span_op)
             return :not_matched unless @matcher.match?(span_op)
 
-            if @rate_limiter.allow?(1) && @sampler.sample!(trace_op)
+            if @rate_limiter.allow? && @sampler.sample!(trace_op)
               span_op.set_metric(Span::Ext::TAG_MECHANISM, Sampling::Ext::Mechanism::SPAN_SAMPLING_RATE)
               span_op.set_metric(Span::Ext::TAG_RULE_RATE, @sample_rate)
               span_op.set_metric(Span::Ext::TAG_MAX_PER_SECOND, @rate_limit)

data/lib/datadog/tracing/span.rb

@@ -27,6 +27,7 @@ module Datadog
         :resource,
         :service,
         :links,
+        :events,
         :type,
         :start_time,
         :status,
@@ -45,6 +46,7 @@ module Datadog
       # * +parent_id+: the identifier of the parent span
       # * +trace_id+: the identifier of the root span for this trace
       # * +service_entry+: whether it is a service entry span.
+      # * +events+: the list of events that occurred while a span was active.
       def initialize(
         name,
         duration: nil,
@@ -60,7 +62,8 @@ module Datadog
         type: nil,
         trace_id: nil,
         service_entry: nil,
-        links: nil
+        links: nil,
+        events: nil
       )
         @name = Core::Utils::SafeDup.frozen_or_dup(name)
         @service = Core::Utils::SafeDup.frozen_or_dup(service)
@@ -90,6 +93,8 @@ module Datadog
 
         @links = links || []
 
+        @events = events || []
+
         # Mark with the service entry span metric, if applicable
         set_metric(Metadata::Ext::TAG_TOP_LEVEL, 1.0) if service_entry
       end
@@ -112,7 +117,7 @@ module Datadog
 
       def set_error(e)
         @status = Metadata::Ext::Errors::STATUS
-        super
+        set_error_tags(e)
       end
 
       # Spans with the same ID are considered the same span
@@ -149,6 +154,8 @@ module Datadog
           h[:duration] = duration_nano
         end
 
+        h[:meta]['events'] = @events.map(&:to_hash).to_json unless @events.empty?
+
         h
       end
 

data/lib/datadog/tracing/span_event.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Datadog
+  module Tracing
+    # Represents a timestamped annotation on a span. It is analogous to structured log message.
+    # @public_api
+    class SpanEvent
+      # @!attribute [r] name
+      #   @return [Integer]
+      attr_reader :name
+
+      # @!attribute [r] attributes
+      #   @return [Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+      attr_reader :attributes
+
+      # @!attribute [r] time_unix_nano
+      #   @return [Integer]
+      attr_reader :time_unix_nano
+
+      def initialize(
+        name,
+        attributes: nil,
+        time_unix_nano: nil
+      )
+        @name = name
+        @attributes = attributes || {}
+        # OpenTelemetry SDK stores span event timestamps in nanoseconds (not seconds).
+        # We will do the same here to avoid unnecessary conversions and inconsistencies.
+        @time_unix_nano = time_unix_nano || (Time.now.to_r * 1_000_000_000).to_i
+      end
+
+      def to_hash
+        h = { name: @name, time_unix_nano: @time_unix_nano }
+        h[:attributes] = attributes unless @attributes.empty?
+        h
+      end
+    end
+  end
+end