cw-datadog 2.23.0.2

data/lib/datadog/tracing/writer.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative 'event'
+require_relative 'runtime/metrics'
+require_relative 'workers'
+
+require_relative 'transport/http'
+
+module Datadog
+  module Tracing
+    # Processor that sends traces and metadata to the agent
+    # DEV: Our goal is for {Datadog::Tracing::Workers::TraceWriter} to replace this class in the future
+    # @public_api
+    class Writer
+      attr_reader \
+        :logger,
+        :transport,
+        :worker,
+        :events,
+        :agent_settings
+
+      def initialize(options = {})
+        @logger = options[:logger] || Datadog.logger
+
+        # writer and transport parameters
+        @buff_size = options.fetch(:buffer_size, Workers::AsyncTransport::DEFAULT_BUFFER_MAX_SIZE)
+        @flush_interval = options.fetch(:flush_interval, Workers::AsyncTransport::DEFAULT_FLUSH_INTERVAL)
+        transport_options = options.fetch(:transport_options, {})
+        @agent_settings = options[:agent_settings]
+
+        # transport and buffers
+        @transport = options.fetch(:transport) do
+          Transport::HTTP.default(agent_settings: agent_settings, logger: logger, **transport_options)
+        end
+
+        @shutdown_timeout = options.fetch(:shutdown_timeout, Workers::AsyncTransport::DEFAULT_SHUTDOWN_TIMEOUT)
+
+        # handles the thread creation after an eventual fork
+        @mutex_after_fork = Mutex.new
+        @pid = nil
+
+        @traces_flushed = 0
+
+        # one worker for traces
+        @worker = nil
+
+        # Once stopped, this writer instance cannot be restarted.
+        # This allow for graceful shutdown, while preventing
+        # the host application from inadvertently start new
+        # threads during shutdown.
+        @stopped = false
+
+        # Callback handler
+        @events = Events.new
+      end
+
+      # Explicitly starts the {Writer}'s internal worker.
+      #
+      # The {Writer} is also automatically started when necessary during calls to {.write}.
+      def start
+        @mutex_after_fork.synchronize do
+          return false if @stopped
+
+          pid = Process.pid
+          return if @worker && pid == @pid
+
+          @pid = pid
+
+          start_worker
+          true
+        end
+      end
+
+      # Gracefully shuts down this writer.
+      #
+      # Once stopped methods calls won't fail, but
+      # no internal work will be performed.
+      #
+      # It is not possible to restart a stopped writer instance.
+      def stop
+        @mutex_after_fork.synchronize { stop_worker }
+      end
+
+      # flush spans to the trace-agent, handles spans only
+      # @!visibility private
+      def send_spans(traces, transport)
+        return true if traces.empty?
+
+        # Send traces and get responses
+        responses = transport.send_traces(traces)
+
+        # Tally up successful flushes
+        responses.reject { |x| x.internal_error? || x.server_error? }.each do |response|
+          @traces_flushed += response.trace_count
+        end
+
+        events.after_send.publish(self, responses)
+
+        # Return if server error occurred.
+        !responses.find(&:server_error?)
+      end
+
+      # enqueue the trace for submission to the API
+      def write(trace)
+        # In multiprocess environments, the main process initializes the +Writer+ instance and if
+        # the process forks (i.e. a web server like Unicorn or Puma with multiple workers) the new
+        # processes will share the same +Writer+ until the first write (COW). Because of that,
+        # each process owns a different copy of the +@buffer+ after each write and so the
+        # +AsyncTransport+ will not send data to the trace agent.
+        #
+        # This check ensures that if a process doesn't own the current +Writer+, async workers
+        # will be initialized again (but only once for each process).
+        start if @worker.nil? || @pid != Process.pid
+
+        # TODO: Remove this, and have the tracer pump traces directly to runtime metrics
+        #       instead of working through the trace writer.
+        # Associate trace with runtime metrics
+        Runtime::Metrics.associate_trace(trace)
+
+        worker_local = @worker
+
+        if worker_local
+          worker_local.enqueue_trace(trace)
+        elsif !@stopped
+          logger.debug('Writer either failed to start or was stopped before #write could complete')
+        end
+      end
+
+      # stats returns a dictionary of stats about the writer.
+      def stats
+        {
+          traces_flushed: @traces_flushed,
+          transport: @transport.stats
+        }
+      end
+
+      # Callback behavior
+      class Events
+        attr_reader \
+          :after_send
+
+        def initialize
+          @after_send = AfterSend.new
+        end
+
+        # Triggered after the writer sends traces through the transport.
+        # Provides the Writer instance and transport response list to the callback.
+        class AfterSend < Tracing::Event
+          def initialize
+            super(:after_send)
+          end
+        end
+      end
+
+      private
+
+      # spawns a worker for spans; they share the same transport which is thread-safe
+      # @!visibility private
+      def start_worker
+        @trace_handler = ->(items, transport) { send_spans(items, transport) }
+        @worker = Workers::AsyncTransport.new(
+          transport: @transport,
+          buffer_size: @buff_size,
+          on_trace: @trace_handler,
+          interval: @flush_interval,
+          shutdown_timeout: @shutdown_timeout,
+          logger: logger,
+        )
+
+        @worker.start
+      end
+
+      def stop_worker
+        @stopped = true
+
+        return if @worker.nil?
+
+        @worker.stop
+        @worker = nil
+
+        true
+      end
+
+      def reset_stats!
+        @traces_flushed = 0
+        @transport.stats.reset!
+      end
+    end
+  end
+end

data/lib/datadog/tracing.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require_relative 'core'
+require_relative 'tracing/pipeline'
+
+module Datadog
+  # Datadog APM tracing public API.
+  #
+  # The Datadog team ensures that public methods in this module
+  # only receive backwards compatible changes, and breaking changes
+  # will only occur in new major versions releases.
+  # @public_api
+  module Tracing
+    class << self
+      # (see Datadog::Tracing::Tracer#trace)
+      # @public_api
+      def trace(
+        name,
+        continue_from: nil,
+        on_error: nil,
+        resource: nil,
+        service: nil,
+        start_time: nil,
+        tags: nil,
+        type: nil,
+        id: nil,
+        &block
+      )
+        current_tracer = tracer
+        
+        # 如果 tracer 未初始化（Cloudwise 初始化失败或组件未就绪），创建空 span
+        if current_tracer.nil?
+          span = SpanOperation.new(name)
+          if block
+            trace = TraceOperation.new
+            return yield(span, trace)
+          else
+            return span
+          end
+        end
+
+        current_tracer.trace(
+          name,
+          continue_from: continue_from,
+          on_error: on_error,
+          resource: resource,
+          service: service,
+          start_time: start_time,
+          tags: tags,
+          type: type,
+          id: id,
+          &block
+        )
+      end
+
+      # (see Datadog::Tracing::Tracer#continue_trace!)
+      # @public_api
+      def continue_trace!(digest, &block)
+        current_tracer = tracer
+        
+        # 如果 tracer 未初始化，创建空 span
+        if current_tracer.nil?
+          span = SpanOperation.new('continue_trace')
+          if block
+            trace = TraceOperation.new
+            return yield(span, trace)
+          else
+            return span
+          end
+        end
+        
+        current_tracer.continue_trace!(digest, &block)
+      end
+
+      # The tracer's internal logger instance.
+      # All tracing log output is handled by this object.
+      #
+      # The logger can be configured through {.configure},
+      # through {Datadog::Core::Configuration::Settings::DSL::Logger} options.
+      #
+      # @!attribute [r] logger
+      # @public_api
+      def logger
+        Datadog.logger
+      end
+
+      # (see Datadog::Tracing::Tracer#active_trace)
+      # @public_api
+      def active_trace
+        current_tracer = tracer
+        return unless current_tracer
+
+        current_tracer.active_trace
+      end
+
+      # (see Datadog::Tracing::Tracer#active_span)
+      # @public_api
+      def active_span
+        current_tracer = tracer
+        return unless current_tracer
+
+        current_tracer.active_span
+      end
+
+      # (see Datadog::Tracing::TraceSegment#keep!)
+      # If no trace is active, no action is taken.
+      # @public_api
+      def keep!
+        trace = active_trace
+        trace&.keep!
+      end
+
+      # (see Datadog::Tracing::TraceSegment#reject!)
+      # If no trace is active, no action is taken.
+      # @public_api
+      def reject!
+        trace = active_trace
+        trace&.reject!
+      end
+
+      # (see Datadog::Tracing::Tracer#active_correlation)
+      # @public_api
+      def correlation
+        # We access this in this way as:
+        # * If the components have not been initialized, it doesn't make sense to initialize datadog just to say
+        #   'nil' here
+        # * It prevents recursive initialization attempts, see https://github.com/DataDog/dd-trace-rb/issues/3385
+        components = Datadog.send(:components, allow_initialization: false)
+        current_tracer = components.tracer if components
+
+        return Datadog::Tracing::Correlation::Identifier.new unless current_tracer
+
+        current_tracer.active_correlation
+      end
+
+      # Textual representation of {.correlation}, which can be
+      # added to individual log lines in order to correlate them with the active
+      # trace.
+      #
+      # Example:
+      #
+      # ```
+      # MyLogger.log("#{Datadog::Tracing.log_correlation}] My message")
+      # # dd.env=prod dd.service=auth dd.version=13.8 dd.trace_id=5458478252992251 dd.span_id=7117552347370098 My message
+      # ```
+      #
+      # @return [String] correlation information; or an empty String if Tracing is disabled (`!enabled?`)
+      # @public_api
+      def log_correlation
+        return '' unless enabled?
+
+        correlation.to_log_format
+      end
+
+      # Returns the baggage for the current trace.
+      #
+      # If there is no active trace, a new one is created.
+      #
+      # @return [Datadog::Tracing::Distributed::Baggage] The baggage for the current trace.
+      # @public_api
+      def baggage
+        # Baggage should not be dependent on there being an active trace.
+        # So we create a new TraceOperation if there isn't one.
+        active_trace = self.active_trace || tracer.continue_trace!(nil)
+        active_trace.baggage ||= {}
+        active_trace.baggage
+      end
+
+      # Gracefully shuts down the tracer.
+      #
+      # The public tracing API will still respond to method calls as usual
+      # but might not internally perform the expected internal work after shutdown.
+      #
+      # This avoids errors being raised across the host application
+      # during shutdown while allowing for the graceful decommission of resources.
+      #
+      # {.shutdown!} cannot be reversed.
+      # @public_api
+      def shutdown!
+        current_tracer = tracer
+        return unless current_tracer
+
+        current_tracer.shutdown!
+      end
+
+      # (see Datadog::Tracing::Pipeline.before_flush)
+      def before_flush(*processors, &processor_block)
+        Pipeline.before_flush(*processors, &processor_block)
+      end
+
+      # Is the tracer collecting telemetry data in this process?
+      # @return [Boolean] `true` if the tracer is collecting data in this process, otherwise `false`.
+      def enabled?
+        current_tracer = tracer
+        return false unless current_tracer
+
+        current_tracer.enabled
+      end
+
+      private
+
+      # DEV: components hosts both tracing and profiling inner objects today
+      def components
+        Datadog.send(:components)
+      end
+
+      def tracer
+        current_components = components
+        return nil if current_components.nil?
+        current_components.tracer
+      end
+    end
+  end
+end

data/lib/datadog/version.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module VERSION
+    MAJOR = 2
+    MINOR = 23
+    PATCH = 0
+    PATCH_MINOR = 2
+    PRE = nil
+    BUILD = nil
+    # PRE and BUILD above are modified for dev gems during gem build GHA workflow
+
+    STRING = [MAJOR, MINOR, PATCH,PATCH_MINOR, PRE, BUILD].compact.join('.')
+
+    MINIMUM_RUBY_VERSION = '2.5.0'
+
+    # Restrict the installation of this gem with untested future versions of Ruby.
+    #
+    # This prevents crashes in the native extension code and sends a clear signal to the
+    # user that this version of the gem is untested for the host Ruby version.
+    #
+    # To allow testing with the next unreleased version of Ruby, the version check is performed
+    # as `< #{MAXIMUM_RUBY_VERSION}`, meaning prereleases of MAXIMUM_RUBY_VERSION are allowed
+    # but not stable MAXIMUM_RUBY_VERSION releases.
+    MAXIMUM_RUBY_VERSION = '3.5'
+  end
+end

data/lib/datadog.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Load tracing
+require_relative 'datadog/tracing'
+require_relative 'datadog/tracing/contrib'
+
+# Load other products (must follow tracing)
+require_relative 'datadog/profiling'
+require_relative 'datadog/appsec'
+require_relative 'datadog/di'
+require_relative 'datadog/data_streams'
+
+# Line probes will not work on Ruby < 2.6 because of lack of :script_compiled
+# trace point. Activate DI automatically on supported Ruby versions but
+# always load its settings so that, for example, turning DI off when
+# we are on Ruby 2.5 does not produce exceptions.
+require_relative 'datadog/di/boot' if RUBY_VERSION >= '2.6' && RUBY_ENGINE != 'jruby'
+
+require_relative 'datadog/error_tracking'
+require_relative 'datadog/kit'