ls-trace 0.1.1

data/lib/ddtrace.rb

@@ -0,0 +1,63 @@
+require 'thread'
+
+# During development, we load `ddtrace` by through `ddtrace.gemspec`,
+# which in turn eager loads 'ddtrace/version'.
+#
+# Users load this gem by requiring this file.
+# We need to ensure that any files loaded in our gemspec are also loaded here.
+require 'ddtrace/version'
+
+require 'ddtrace/pin'
+require 'ddtrace/tracer'
+require 'ddtrace/error'
+require 'ddtrace/quantization/hash'
+require 'ddtrace/quantization/http'
+require 'ddtrace/pipeline'
+require 'ddtrace/configuration'
+require 'ddtrace/patcher'
+require 'ddtrace/augmentation'
+require 'ddtrace/metrics'
+
+# \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
+module Datadog
+  extend Augmentation
+  extend Configuration
+
+  # Load and extend Contrib by default
+  require 'ddtrace/contrib/extensions'
+  extend Contrib::Extensions
+end
+
+require 'ddtrace/contrib/action_pack/integration'
+require 'ddtrace/contrib/action_view/integration'
+require 'ddtrace/contrib/active_model_serializers/integration'
+require 'ddtrace/contrib/active_record/integration'
+require 'ddtrace/contrib/active_support/integration'
+require 'ddtrace/contrib/aws/integration'
+require 'ddtrace/contrib/concurrent_ruby/integration'
+require 'ddtrace/contrib/dalli/integration'
+require 'ddtrace/contrib/delayed_job/integration'
+require 'ddtrace/contrib/elasticsearch/integration'
+require 'ddtrace/contrib/ethon/integration'
+require 'ddtrace/contrib/excon/integration'
+require 'ddtrace/contrib/faraday/integration'
+require 'ddtrace/contrib/grape/integration'
+require 'ddtrace/contrib/graphql/integration'
+require 'ddtrace/contrib/grpc/integration'
+require 'ddtrace/contrib/http/integration'
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/mysql2/integration'
+require 'ddtrace/contrib/mongodb/integration'
+require 'ddtrace/contrib/racecar/integration'
+require 'ddtrace/contrib/rack/integration'
+require 'ddtrace/contrib/rails/integration'
+require 'ddtrace/contrib/rake/integration'
+require 'ddtrace/contrib/redis/integration'
+require 'ddtrace/contrib/resque/integration'
+require 'ddtrace/contrib/rest_client/integration'
+require 'ddtrace/contrib/sequel/integration'
+require 'ddtrace/contrib/shoryuken/integration'
+require 'ddtrace/contrib/sidekiq/integration'
+require 'ddtrace/contrib/sinatra/integration'
+require 'ddtrace/contrib/sucker_punch/integration'
+require 'ddtrace/monkey'

data/lib/ddtrace/analytics.rb

@@ -0,0 +1,29 @@
+require 'ddtrace/ext/analytics'
+
+module Datadog
+  # Defines analytics behavior
+  module Analytics
+    class << self
+      def set_sample_rate(span, sample_rate)
+        return if span.nil? || !sample_rate.is_a?(Numeric)
+        span.set_metric(Datadog::Ext::Analytics::TAG_SAMPLE_RATE, sample_rate)
+      end
+    end
+
+    # Extension for Datadog::Span
+    module Span
+      def set_tag(key, value)
+        case key
+        when Ext::Analytics::TAG_ENABLED
+          # If true, set rate to 1.0, otherwise set 0.0.
+          value = value == true ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
+          Analytics.set_sample_rate(self, value)
+        when Ext::Analytics::TAG_SAMPLE_RATE
+          Analytics.set_sample_rate(self, value)
+        else
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/augmentation.rb

@@ -0,0 +1,13 @@
+require 'ddtrace/augmentation/method_wrapper'
+require 'ddtrace/augmentation/method_wrapping'
+require 'ddtrace/augmentation/shim'
+
+module Datadog
+  # Namespace for components that help modify
+  # existing code for instrumentation purposes.
+  module Augmentation
+    def shim(object, &block)
+      Shim.new(object, &block)
+    end
+  end
+end

data/lib/ddtrace/augmentation/method_wrapper.rb

@@ -0,0 +1,20 @@
+module Datadog
+  # Represents an wrapped method, with a reference to the original block
+  # and the block that wraps around it.
+  class MethodWrapper
+    attr_reader \
+      :original,
+      :wrapper
+
+    DEFAULT_WRAPPER = proc { |original, *args, &block| original.call(*args, &block) }
+
+    def initialize(original, &block)
+      @original = original
+      @wrapper = block_given? ? block : DEFAULT_WRAPPER
+    end
+
+    def call(*args, &block)
+      wrapper.call(original, *args, &block)
+    end
+  end
+end

data/lib/ddtrace/augmentation/method_wrapping.rb

@@ -0,0 +1,38 @@
+require 'set'
+require 'ddtrace/patcher'
+
+module Datadog
+  # Shorthands for wrapping methods
+  module MethodWrapping
+    include Datadog::Patcher
+
+    def wrapped_methods
+      @wrapped_methods ||= Set.new
+    end
+
+    # Adds method block directly to the object.
+    # Block is evaluated in the context of the object.
+    # Faster than #wrap_method!
+    def override_method!(method_name, &block)
+      return unless block_given?
+
+      without_warnings do
+        define_singleton_method(method_name, &block).tap do
+          wrapped_methods.add(method_name)
+        end
+      end
+    end
+
+    # Adds method wrapper to the object.
+    # Block is evaluated in the original context of the block.
+    # Slower than #override_method!
+    def wrap_method!(original_method, &block)
+      return unless block_given?
+      original_method = original_method.is_a?(Symbol) ? method(original_method) : original_method
+
+      override_method!(original_method.name) do |*original_args, &original_block|
+        block.call(original_method, *original_args, &original_block)
+      end
+    end
+  end
+end

data/lib/ddtrace/augmentation/shim.rb

@@ -0,0 +1,102 @@
+require 'set'
+require 'ddtrace/patcher'
+require 'ddtrace/augmentation/method_wrapping'
+
+module Datadog
+  # A "stand-in" that intercepts calls to another object. i.e. man-in-the-middle.
+  # This shim forwards all methods to object, except those overriden.
+  # Useful if you want to intercept inbound behavior to an object without modifying
+  # the object in question, especially useful if the overridding behavior shouldn't be global.
+  class Shim
+    extend Forwardable
+    include Datadog::Patcher
+    include Datadog::MethodWrapping
+
+    METHODS = Set[
+      :override_method!,
+      :shim,
+      :shim?,
+      :shim_target,
+      :wrap_method!,
+      :wrapped_methods
+    ].freeze
+
+    EXCLUDED_METHODS = Set[
+      # For all objects
+      :__binding__,
+      :__id__,
+      :__send__,
+      :extend,
+      :itself,
+      :object_id,
+      :respond_to?,
+      :tap
+    ].freeze
+
+    attr_reader :shim_target, :shim
+
+    def self.shim?(object)
+      # Check whether it responds to #shim? because otherwise the
+      # Shim forwards all method calls, including type checks to
+      # the wrapped object, to mimimize its intrusion.
+      object.respond_to?(:shim?)
+    end
+
+    # Pass this a block to override methods
+    def initialize(shim_target)
+      @shim = self
+      @shim_target = shim_target
+
+      # Save a reference to the original :define_singleton_method
+      # so methods can be defined on the shim after forwarding is applied.
+      @definition_method = method(:define_singleton_method)
+
+      # Wrap any methods
+      yield(self) if block_given?
+
+      # Forward methods
+      forwarded_methods = (
+        shim_target.public_methods.to_set \
+        - METHODS \
+        - EXCLUDED_METHODS \
+        - wrapped_methods
+      )
+      forward_methods!(*forwarded_methods)
+    end
+
+    def override_method!(method_name, &block)
+      return unless block_given?
+
+      without_warnings do
+        @definition_method.call(method_name, &block).tap do
+          wrapped_methods.add(method_name)
+        end
+      end
+    end
+
+    def wrap_method!(method_name, &block)
+      super(shim_target.method(method_name), &block)
+    end
+
+    def shim?
+      true
+    end
+
+    def respond_to?(method_name)
+      return true if METHODS.include?(method_name)
+      shim_target.respond_to?(method_name)
+    end
+
+    private
+
+    def forward_methods!(*forwarded_methods)
+      return if forwarded_methods.empty?
+
+      singleton_class.send(
+        :def_delegators,
+        :@shim_target,
+        *forwarded_methods
+      )
+    end
+  end
+end

data/lib/ddtrace/buffer.rb

@@ -0,0 +1,119 @@
+require 'thread'
+require 'ddtrace/diagnostics/health'
+require 'ddtrace/runtime/object_space'
+
+module Datadog
+  # Trace buffer that stores application traces. The buffer has a maximum size and when
+  # the buffer is full, a random trace is discarded. This class is thread-safe and is used
+  # automatically by the ``Tracer`` instance when a ``Span`` is finished.
+  class TraceBuffer
+    def initialize(max_size)
+      @max_size = max_size
+
+      @mutex = Mutex.new()
+      @traces = []
+      @closed = false
+
+      # Initialize metric values
+      @buffer_accepted = 0
+      @buffer_accepted_lengths = 0
+      @buffer_dropped = 0
+      @buffer_spans = 0
+    end
+
+    # Add a new ``trace`` in the local queue. This method doesn't block the execution
+    # even if the buffer is full. In that case, a random trace is discarded.
+    def push(trace)
+      @mutex.synchronize do
+        return if @closed
+        len = @traces.length
+        if len < @max_size || @max_size <= 0
+          @traces << trace
+        else
+          # we should replace a random trace with the new one
+          replace_index = rand(len)
+          replaced_trace = @traces[replace_index]
+          @traces[replace_index] = trace
+          measure_drop(replaced_trace)
+        end
+
+        measure_accept(trace)
+      end
+    end
+
+    # Return the current number of stored traces.
+    def length
+      @mutex.synchronize do
+        return @traces.length
+      end
+    end
+
+    # Return if the buffer is empty.
+    def empty?
+      @mutex.synchronize do
+        return @traces.empty?
+      end
+    end
+
+    # Stored traces are returned and the local buffer is reset.
+    def pop
+      @mutex.synchronize do
+        traces = @traces
+        @traces = []
+
+        measure_pop(traces)
+
+        return traces
+      end
+    end
+
+    def close
+      @mutex.synchronize do
+        @closed = true
+      end
+    end
+
+    # Aggregate metrics:
+    # They reflect buffer activity since last #pop.
+    # These may not be as accurate or as granular, but they
+    # don't use as much network traffic as live stats.
+
+    def measure_accept(trace)
+      @buffer_spans += trace.length
+      @buffer_accepted += 1
+      @buffer_accepted_lengths += trace.length
+    rescue StandardError => e
+      Datadog::Tracer.log.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def measure_drop(trace)
+      @buffer_dropped += 1
+      @buffer_spans -= trace.length
+      @buffer_accepted_lengths -= trace.length
+    rescue StandardError => e
+      Datadog::Tracer.log.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+
+    def measure_pop(traces)
+      # Accepted
+      Diagnostics::Health.metrics.queue_accepted(@buffer_accepted)
+      Diagnostics::Health.metrics.queue_accepted_lengths(@buffer_accepted_lengths)
+
+      # Dropped
+      Diagnostics::Health.metrics.queue_dropped(@buffer_dropped)
+
+      # Queue gauges
+      Diagnostics::Health.metrics.queue_max_length(@max_size)
+      Diagnostics::Health.metrics.queue_spans(@buffer_spans)
+      Diagnostics::Health.metrics.queue_length(traces.length)
+
+      # Reset aggregated metrics
+      @buffer_accepted = 0
+      @buffer_accepted_lengths = 0
+      @buffer_dropped = 0
+      @buffer_spans = 0
+    rescue StandardError => e
+      Datadog::Tracer.log.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
+    end
+  end
+end

data/lib/ddtrace/configuration.rb

@@ -0,0 +1,30 @@
+require 'ddtrace/configuration/pin_setup'
+require 'ddtrace/configuration/settings'
+
+module Datadog
+  # Configuration provides a unique access point for configurations
+  module Configuration
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Settings.new
+    end
+
+    def configure(target = configuration, opts = {})
+      if target.is_a?(Settings)
+        yield(target) if block_given?
+      else
+        PinSetup.new(target, opts).call
+      end
+    end
+
+    # Helper methods
+    def tracer
+      configuration.tracer
+    end
+
+    def runtime_metrics
+      tracer.writer.runtime_metrics
+    end
+  end
+end

data/lib/ddtrace/configuration/base.rb

@@ -0,0 +1,82 @@
+require 'ddtrace/environment'
+require 'ddtrace/configuration/options'
+
+module Datadog
+  module Configuration
+    # Basic configuration behavior
+    module Base
+      def self.included(base)
+        base.send(:extend, Datadog::Environment::Helpers)
+        base.send(:include, Options)
+
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for configuration
+      module ClassMethods
+        protected
+
+        # Allows subgroupings of settings to be defined.
+        # e.g. `settings :foo { option :bar }` --> `config.foo.bar`
+        def settings(name, &block)
+          settings_class = new_settings_class(&block)
+
+          option(name) do |o|
+            o.default settings_class.new
+            o.resetter do |value|
+              value.reset! if value.respond_to?(:reset!)
+              value
+            end
+          end
+        end
+
+        private
+
+        def new_settings_class(&block)
+          Class.new { include Datadog::Configuration::Base }.tap do |klass|
+            klass.instance_eval(&block) if block_given?
+          end
+        end
+      end
+
+      # Instance methods for configuration
+      module InstanceMethods
+        def initialize(options = {})
+          configure(options)
+        end
+
+        def configure(opts = {})
+          # Sort the options in preference of dependency order first
+          ordering = self.class.options.dependency_order
+          sorted_opts = opts.sort_by do |name, _value|
+            ordering.index(name) || (ordering.length + 1)
+          end
+
+          # Ruby 2.0 doesn't support Array#to_h
+          sorted_opts = Hash[*sorted_opts.flatten]
+
+          # Apply options in sort order
+          sorted_opts.each do |name, value|
+            if respond_to?("#{name}=")
+              send("#{name}=", value)
+            elsif option_defined?(name)
+              set_option(name, value)
+            end
+          end
+
+          # Apply any additional settings from block
+          yield(self) if block_given?
+        end
+
+        def to_h
+          options_hash
+        end
+
+        def reset!
+          reset_options!
+        end
+      end
+    end
+  end
+end