ddtrace 0.35.2 → 1.1.0

data/lib/ddtrace/workers/runtime_metrics.rb

@@ -1,47 +0,0 @@
-require 'forwardable'
-
-require 'ddtrace/runtime/metrics'
-
-require 'ddtrace/worker'
-require 'ddtrace/workers/polling'
-
-module Datadog
-  module Workers
-    # Emits runtime metrics asynchronously on a timed loop
-    class RuntimeMetrics < Worker
-      extend Forwardable
-      include Workers::Polling
-
-      attr_reader \
-        :metrics
-
-      def initialize(options = {})
-        @metrics = options.fetch(:metrics, Runtime::Metrics.new)
-
-        # Workers::Async::Thread settings
-        self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)
-
-        # Workers::IntervalLoop settings
-        self.interval = options[:interval] if options.key?(:interval)
-        self.back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
-        self.back_off_max = options[:back_off_max] if options.key?(:back_off_max)
-
-        self.enabled = options.fetch(:enabled, false)
-      end
-
-      def perform
-        metrics.flush
-        true
-      end
-
-      def associate_with_span(*args)
-        # Start the worker
-        metrics.associate_with_span(*args).tap { perform }
-      end
-
-      def_delegators \
-        :metrics,
-        :register_service
-    end
-  end
-end

data/lib/ddtrace/workers/trace_writer.rb

@@ -1,199 +0,0 @@
-require 'ddtrace/logger'
-require 'ddtrace/transport/http'
-
-require 'ddtrace/event'
-require 'ddtrace/worker'
-require 'ddtrace/workers/polling'
-require 'ddtrace/workers/queue'
-
-module Datadog
-  module Workers
-    # Writes traces to transport synchronously
-    class TraceWriter < Worker
-      attr_reader \
-        :transport
-
-      def initialize(options = {})
-        transport_options = options.fetch(:transport_options, {})
-
-        if transport_options.is_a?(Proc)
-          transport_options = { on_build: transport_options }
-        end
-
-        transport_options[:hostname] = options[:hostname] if options.key?(:hostname)
-        transport_options[:port] = options[:port] if options.key?(:port)
-
-        @transport = options.fetch(:transport) do
-          Transport::HTTP.default(transport_options)
-        end
-      end
-
-      def perform(traces)
-        write_traces(traces)
-      end
-
-      def write(trace)
-        write_traces([trace])
-      end
-
-      def write_traces(traces)
-        traces = process_traces(traces)
-        flush_traces(traces)
-      rescue StandardError => e
-        Datadog.logger.error(
-          "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{e.backtrace.first}"
-        )
-      end
-
-      def process_traces(traces)
-        # Run traces through the processing pipeline
-        traces = Pipeline.process!(traces)
-
-        # Inject hostname if configured to do so
-        inject_hostname!(traces) if Datadog.configuration.report_hostname
-
-        traces
-      end
-
-      def flush_traces(traces)
-        transport.send_traces(traces).tap do |response|
-          flush_completed.publish(response)
-        end
-      end
-
-      def inject_hostname!(traces)
-        traces.each do |trace|
-          next if trace.first.nil?
-
-          hostname = Datadog::Runtime::Socket.hostname
-          unless hostname.nil? || hostname.empty?
-            trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname)
-          end
-        end
-      end
-
-      def flush_completed
-        @flush_completed ||= FlushCompleted.new
-      end
-
-      # Flush completed event for worker
-      class FlushCompleted < Event
-        def initialize
-          super(:flush_completed)
-        end
-
-        def publish(response)
-          super(response)
-        end
-      end
-    end
-
-    # Writes traces to transport asynchronously,
-    # using a thread & buffer.
-    class AsyncTraceWriter < TraceWriter
-      include Workers::Queue
-      include Workers::Polling
-
-      DEFAULT_BUFFER_MAX_SIZE = 1000
-      FORK_POLICY_ASYNC = :async
-      FORK_POLICY_SYNC = :sync
-
-      attr_writer \
-        :async
-
-      def initialize(options = {})
-        # Workers::TraceWriter settings
-        super
-
-        # Workers::Polling settings
-        self.enabled = options.fetch(:enabled, true)
-
-        # Workers::Async::Thread settings
-        @async = true
-        self.fork_policy = options.fetch(:fork_policy, FORK_POLICY_ASYNC)
-
-        # Workers::IntervalLoop settings
-        self.loop_base_interval = options[:interval] if options.key?(:interval)
-        self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
-        self.loop_back_off_max = options[:back_off_max] if options.key?(:back_off_max)
-
-        # Workers::Queue settings
-        @buffer_size = options.fetch(:buffer_size, DEFAULT_BUFFER_MAX_SIZE)
-        self.buffer = TraceBuffer.new(@buffer_size)
-      end
-
-      # NOTE: #perform is wrapped by other modules:
-      #       Polling --> Async --> IntervalLoop --> AsyncTraceWriter --> TraceWriter
-      def perform(traces)
-        super(traces).tap do |responses|
-          loop_back_off! if responses.find(&:server_error?)
-        end
-      end
-
-      def stop(*args)
-        buffer.close if running?
-        super
-      end
-
-      def enqueue(trace)
-        buffer.push(trace)
-      end
-
-      def dequeue
-        # Wrap results in Array because they are
-        # splatted as args against TraceWriter#perform.
-        [buffer.pop]
-      end
-
-      def work_pending?
-        !buffer.empty?
-      end
-
-      def async?
-        @async == true
-      end
-
-      def fork_policy=(policy)
-        # Translate to Workers::Async::Thread policy
-        thread_fork_policy = case policy
-                             when Workers::Async::Thread::FORK_POLICY_STOP
-                               policy
-                             when FORK_POLICY_SYNC
-                               # Stop the async thread because the writer
-                               # will bypass and run synchronously.
-                               Workers::Async::Thread::FORK_POLICY_STOP
-                             else
-                               Workers::Async::Thread::FORK_POLICY_RESTART
-                             end
-
-        # Update thread fork policy
-        super(thread_fork_policy)
-
-        # Update local policy
-        @writer_fork_policy = policy
-      end
-
-      def after_fork
-        # In multiprocess environments, forks will share the same buffer until its written to.
-        # A.K.A. copy-on-write. We don't want forks to write traces generated from another process.
-        # Instead, we reset it after the fork. (Make sure any enqueue operations happen after this.)
-        self.buffer = TraceBuffer.new(@buffer_size)
-
-        # Switch to synchronous mode if configured to do so.
-        # In some cases synchronous writing is preferred because the fork will be short lived.
-        @async = false if @writer_fork_policy == FORK_POLICY_SYNC
-      end
-
-      def write(trace)
-        # Start worker thread. If the process has forked, it will trigger #after_fork to
-        # reconfigure the worker accordingly.
-        # NOTE: It's important we do this before queuing or it will drop the current trace,
-        #       because #after_fork resets the buffer.
-        perform
-
-        # Queue the trace if running asynchronously, otherwise short-circuit and write it directly.
-        async? ? enqueue(trace) : write_traces([trace])
-      end
-    end
-  end
-end

data/lib/ddtrace/workers.rb

@@ -1,117 +0,0 @@
-require 'time'
-
-require 'ddtrace/workers/trace_writer'
-require 'ddtrace/workers/runtime_metrics'
-
-require 'ddtrace/buffer'
-require 'ddtrace/runtime/metrics'
-
-module Datadog
-  module Workers
-    # Asynchronous worker that executes a +Send()+ operation after given
-    # seconds. Under the hood, it uses +Concurrent::TimerTask+ so that the thread
-    # will perform a task at regular intervals. The thread can be stopped
-    # with the +stop()+ method and can start with the +start()+ method.
-    class AsyncTransport
-      DEFAULT_BUFFER_MAX_SIZE = 1000
-      DEFAULT_FLUSH_INTERVAL = 1
-      DEFAULT_TIMEOUT = 5
-      BACK_OFF_RATIO = 1.2
-      BACK_OFF_MAX = 5
-      SHUTDOWN_TIMEOUT = 1
-
-      attr_reader \
-        :trace_buffer
-
-      def initialize(options = {})
-        @transport = options[:transport]
-
-        # Callbacks
-        @trace_task = options[:on_trace]
-
-        # Intervals
-        interval = options.fetch(:interval, DEFAULT_FLUSH_INTERVAL)
-        @flush_interval = interval
-        @back_off = interval
-
-        # Buffers
-        buffer_size = options.fetch(:buffer_size, DEFAULT_BUFFER_MAX_SIZE)
-        @trace_buffer = TraceBuffer.new(buffer_size)
-
-        # Threading
-        @shutdown = ConditionVariable.new
-        @mutex = Mutex.new
-        @worker = nil
-        @run = false
-      end
-
-      # Callback function that process traces and executes the +send_traces()+ method.
-      def callback_traces
-        return true if @trace_buffer.empty?
-
-        begin
-          traces = @trace_buffer.pop
-          traces = Pipeline.process!(traces)
-          @trace_task.call(traces, @transport) unless @trace_task.nil?
-        rescue StandardError => e
-          # ensures that the thread will not die because of an exception.
-          # TODO[manu]: findout the reason and reschedule the send if it's not
-          # a fatal exception
-          Datadog.logger.error(
-            "Error during traces flush: dropped #{traces.length} items. Cause: #{e} Location: #{e.backtrace.first}"
-          )
-        end
-      end
-
-      # Start the timer execution.
-      def start
-        @mutex.synchronize do
-          return if @run
-          @run = true
-          Datadog.logger.debug("Starting thread in the process: #{Process.pid}")
-          @worker = Thread.new { perform }
-        end
-      end
-
-      # Closes all available queues and waits for the trace buffer to flush
-      def stop
-        @mutex.synchronize do
-          return unless @run
-
-          @trace_buffer.close
-          @run = false
-          @shutdown.signal
-        end
-
-        join
-        true
-      end
-
-      # Block until executor shutdown is complete or until timeout seconds have passed.
-      def join
-        @worker.join(SHUTDOWN_TIMEOUT)
-      end
-
-      # Enqueue an item in the trace internal buffer. This operation is thread-safe
-      # because uses the +TraceBuffer+ data structure.
-      def enqueue_trace(trace)
-        @trace_buffer.push(trace)
-      end
-
-      private
-
-      alias flush_data callback_traces
-
-      def perform
-        loop do
-          @back_off = flush_data ? @flush_interval : [@back_off * BACK_OFF_RATIO, BACK_OFF_MAX].min
-
-          @mutex.synchronize do
-            return if !@run && @trace_buffer.empty?
-            @shutdown.wait(@mutex, @back_off) if @run # do not wait when shutting down
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/writer.rb

@@ -1,154 +0,0 @@
-require 'json'
-
-require 'ddtrace/ext/net'
-require 'ddtrace/runtime/socket'
-
-require 'ddtrace/transport/http'
-require 'ddtrace/transport/io'
-require 'ddtrace/encoding'
-require 'ddtrace/workers'
-
-module Datadog
-  # Processor that sends traces and metadata to the agent
-  class Writer
-    attr_reader \
-      :priority_sampler,
-      :transport,
-      :worker
-
-    def initialize(options = {})
-      # 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, {})
-
-      # priority sampling
-      if options[:priority_sampler]
-        @priority_sampler = options[:priority_sampler]
-        transport_options[:api_version] ||= Transport::HTTP::API::V4
-      end
-
-      # transport and buffers
-      @transport = options.fetch(:transport) do
-        Transport::HTTP.default(transport_options)
-      end
-
-      # handles the thread creation after an eventual fork
-      @mutex_after_fork = Mutex.new
-      @pid = nil
-
-      @traces_flushed = 0
-
-      # one worker for traces
-      @worker = nil
-    end
-
-    # spawns a worker for spans; they share the same transport which is thread-safe
-    def start
-      @pid = Process.pid
-      @trace_handler = ->(items, transport) { send_spans(items, transport) }
-      @worker = Datadog::Workers::AsyncTransport.new(
-        transport: @transport,
-        buffer_size: @buff_size,
-        on_trace: @trace_handler,
-        interval: @flush_interval
-      )
-
-      @worker.start
-    end
-
-    # stops worker for spans.
-    def stop
-      return if worker.nil?
-      @worker.stop
-      @worker = nil
-      true
-    end
-
-    # flush spans to the trace-agent, handles spans only
-    def send_spans(traces, transport)
-      return true if traces.empty?
-
-      # Inject hostname if configured to do so
-      inject_hostname!(traces) if Datadog.configuration.report_hostname
-
-      # 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
-
-      # Update priority sampler
-      update_priority_sampler(responses.last)
-
-      # Return if server error occurred.
-      !responses.find(&:server_error?)
-    end
-
-    # enqueue the trace for submission to the API
-    def write(trace, services = nil)
-      unless services.nil?
-        Datadog::Patcher.do_once('Writer#write') do
-          Datadog.logger.warn(%(
-            write: Writing services has been deprecated and no longer need to be provided.
-            write(traces, services) can be updated to write(traces)
-          ))
-        end
-      end
-
-      # 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).
-      pid = Process.pid
-      if pid != @pid # avoid using Mutex when pids are equal
-        @mutex_after_fork.synchronize do
-          # we should start threads because the worker doesn't own this
-          start if pid != @pid
-        end
-      end
-
-      # TODO: Remove this, and have the tracer pump traces directly to runtime metrics
-      #       instead of working through the trace writer.
-      # Associate root span with runtime metrics
-      if Datadog.configuration.runtime_metrics.enabled && !trace.empty?
-        Datadog.runtime_metrics.associate_with_span(trace.first)
-      end
-
-      @worker.enqueue_trace(trace)
-    end
-
-    # stats returns a dictionary of stats about the writer.
-    def stats
-      {
-        traces_flushed: @traces_flushed,
-        transport: @transport.stats
-      }
-    end
-
-    private
-
-    def inject_hostname!(traces)
-      traces.each do |trace|
-        next if trace.first.nil?
-
-        hostname = Datadog::Runtime::Socket.hostname
-        unless hostname.nil? || hostname.empty?
-          trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname)
-        end
-      end
-    end
-
-    def update_priority_sampler(response)
-      return unless response && !response.internal_error? && priority_sampler && response.service_rates
-
-      priority_sampler.update(response.service_rates)
-    end
-  end
-end

data/tasks/release_gem.rake

@@ -1,28 +0,0 @@
-desc 'create a new indexed repository'
-task :'release:gem' do
-  raise 'Missing environment variable S3_DIR' if !S3_DIR || S3_DIR.empty?
-  # load existing deployed gems
-  sh "aws s3 cp --exclude 'docs/*' --recursive s3://#{S3_BUCKET}/#{S3_DIR}/ ./rubygems/"
-
-  # create folders
-  sh 'mkdir -p ./gems'
-  sh 'mkdir -p ./rubygems/gems'
-
-  # build the gem
-  Rake::Task['build'].execute
-
-  # copy the output in the indexed folder
-  sh 'cp pkg/*.gem ./rubygems/gems/'
-
-  # generate the gems index
-  sh 'gem generate_index -v --no-modern -d ./rubygems'
-
-  # remove all local repository gems to limit files needed to be uploaded
-  sh 'rm -f ./rubygems/gems/*'
-
-  # re-add new gems
-  sh 'cp pkg/*.gem ./rubygems/gems/'
-
-  # deploy a static gem registry
-  sh "aws s3 cp --recursive ./rubygems/ s3://#{S3_BUCKET}/#{S3_DIR}/"
-end