fair-ddtrace 0.8.2.a

data/gemfiles/contrib.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "elasticsearch-transport"
+gem "grape"
+gem "rack"
+gem "rack-test"
+gem "redis"
+gem "hiredis"
+gem "sinatra"
+gem "sqlite3"
+gem "activerecord"
+gem "sidekiq"
+
+gemspec path: "../"

data/gemfiles/contrib_old.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "elasticsearch-transport"
+gem "redis", "< 4.0.0"
+gem "hiredis"
+gem "rack", "1.4.7"
+gem "rack-test"
+gem "sinatra", "1.4.5"
+gem "sqlite3"
+gem "activerecord", "3.2.22.5"
+gem "sidekiq", "4.0.0"
+
+gemspec path: "../"

data/gemfiles/rails30_postgres.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.0.20"
+gem "pg", "0.15.1", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+
+gemspec path: "../"

data/gemfiles/rails30_postgres_sidekiq.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.0.20"
+gem "pg", "0.15.1", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+gem "sidekiq", "4.0.0"
+
+gemspec path: "../"

data/gemfiles/rails32_mysql2.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.2.22.5"
+gem "mysql2", "0.3.21", platform: :ruby
+gem "activerecord-mysql-adapter", platform: :ruby
+gem "activerecord-jdbcmysql-adapter", platform: :jruby
+
+gemspec path: "../"

data/gemfiles/rails32_postgres.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.2.22.5"
+gem "pg", "0.15.1", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+
+gemspec path: "../"

data/gemfiles/rails32_postgres_redis.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.2.22.5"
+gem "pg", "0.15.1", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+gem "redis-rails"
+
+gemspec path: "../"

data/gemfiles/rails32_postgres_sidekiq.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "test-unit"
+gem "rails", "3.2.22.5"
+gem "pg", "0.15.1", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+gem "sidekiq", "4.0.0"
+
+gemspec path: "../"

data/gemfiles/rails4_mysql2.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.7.1"
+gem "mysql2", platform: :ruby
+gem "activerecord-jdbcmysql-adapter", platform: :jruby
+
+gemspec path: "../"

data/gemfiles/rails4_postgres.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.7.1"
+gem "pg", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+
+gemspec path: "../"

data/gemfiles/rails4_postgres_redis.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.7.1"
+gem "pg", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+gem "redis-rails"
+
+gemspec path: "../"

data/gemfiles/rails4_postgres_sidekiq.gemfile

@@ -0,0 +1,11 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "4.2.7.1"
+gem "pg", platform: :ruby
+gem "activerecord-jdbcpostgresql-adapter", platform: :jruby
+gem "sidekiq"
+gem "activejob"
+
+gemspec path: "../"

data/gemfiles/rails5_mysql2.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.1"
+gem "mysql2", platform: :ruby
+
+gemspec path: "../"

data/gemfiles/rails5_postgres.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.1"
+gem "pg", platform: :ruby
+
+gemspec path: "../"

data/gemfiles/rails5_postgres_redis.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.1"
+gem "pg", platform: :ruby
+gem "redis-rails"
+
+gemspec path: "../"

data/gemfiles/rails5_postgres_sidekiq.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "5.0.1"
+gem "pg", platform: :ruby
+gem "sidekiq"
+gem "activejob"
+
+gemspec path: "../"

data/lib/ddtrace.rb

@@ -0,0 +1,73 @@
+require 'ddtrace/monkey'
+require 'ddtrace/pin'
+require 'ddtrace/tracer'
+require 'ddtrace/error'
+
+# \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
+module Datadog
+  @tracer = Datadog::Tracer.new()
+
+  # Default tracer that can be used as soon as +ddtrace+ is required:
+  #
+  #   require 'ddtrace'
+  #
+  #   span = Datadog.tracer.trace('web.request')
+  #   span.finish()
+  #
+  # If you want to override the default tracer, the recommended way
+  # is to "pin" your own tracer onto your traced component:
+  #
+  #   tracer = Datadog::Tracer.new
+  #   pin = Datadog::Pin.get_from(mypatchcomponent)
+  #   pin.tracer = tracer
+
+  def self.tracer
+    @tracer
+  end
+end
+
+# Datadog auto instrumentation for frameworks
+if defined?(Rails::VERSION)
+  if !ENV['DISABLE_DATADOG_RAILS']
+    if Rails::VERSION::MAJOR.to_i >= 3
+      require 'ddtrace/contrib/rails/framework'
+      require 'ddtrace/contrib/rails/middlewares'
+
+      module Datadog
+        # Railtie class initializes
+        class Railtie < Rails::Railtie
+          config.app_middleware.use(Datadog::Contrib::Rails::ExceptionMiddleware)
+
+          # auto instrument Rails and third party components after
+          # the framework initialization
+          options = {}
+          config.after_initialize do |app|
+            Datadog::Contrib::Rails::Framework.configure(config: app.config)
+            Datadog::Contrib::Rails::Framework.auto_instrument()
+            Datadog::Contrib::Rails::Framework.auto_instrument_redis()
+            Datadog::Contrib::Rails::Framework.auto_instrument_grape()
+
+            # override Rack Middleware configurations with Rails
+            options.update(::Rails.configuration.datadog_trace)
+          end
+
+          # Configure datadog settings before building the middleware stack.
+          # This is required because the middleware stack is frozen after
+          # the initialization and so it's too late to add our tracing
+          # functionalities.
+          initializer :datadog_config, before: :build_middleware_stack do |app|
+            app.config.middleware.insert_before(
+              0, Datadog::Contrib::Rack::TraceMiddleware, options
+            )
+          end
+        end
+      end
+    else
+      Datadog::Tracer.log.warn 'Detected a Rails version < 3.x.'\
+                               'This version is not supported yet and the'\
+                               'auto-instrumentation for core components will be disabled.'
+    end
+  else
+    Datadog::Tracer.log.info 'Skipping Rails auto-instrumentation, DISABLE_DATADOG_RAILS is set.'
+  end
+end

data/lib/ddtrace/buffer.rb

@@ -0,0 +1,52 @@
+require 'thread'
+
+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 = []
+    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
+        len = @traces.length
+        if len < @max_size || @max_size <= 0
+          @traces << trace
+        else
+          # we should replace a random trace with the new one
+          @traces[rand(len)] = trace
+        end
+      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 = []
+        return traces
+      end
+    end
+  end
+end

data/lib/ddtrace/context.rb

@@ -0,0 +1,145 @@
+require 'thread'
+
+module Datadog
+  # \Context is used to keep track of a hierarchy of spans for the current
+  # execution flow. During each logical execution, the same \Context is
+  # used to represent a single logical trace, even if the trace is built
+  # asynchronously.
+  #
+  # A single code execution may use multiple \Context if part of the execution
+  # must not be related to the current tracing. As example, a delayed job may
+  # compose a standalone trace instead of being related to the same trace that
+  # generates the job itself. On the other hand, if it's part of the same
+  # \Context, it will be related to the original trace.
+  #
+  # This data structure is thread-safe.
+  class Context
+    # Initialize a new thread-safe \Context.
+    def initialize
+      @mutex = Mutex.new
+      reset
+    end
+
+    def reset
+      @trace = []
+      @sampled = false
+      @finished_spans = 0
+      @current_span = nil
+    end
+
+    # Return the last active span that corresponds to the last inserted
+    # item in the trace list. This cannot be considered as the current active
+    # span in asynchronous environments, because some spans can be closed
+    # earlier while child spans still need to finish their traced execution.
+    def current_span
+      @mutex.synchronize do
+        return @current_span
+      end
+    end
+
+    # Add a span to the context trace list, keeping it as the last active span.
+    def add_span(span)
+      @mutex.synchronize do
+        @current_span = span
+        @sampled = span.sampled
+        @trace << span
+        span.context = self
+      end
+    end
+
+    # Mark a span as a finished, increasing the internal counter to prevent
+    # cycles inside _trace list.
+    def close_span(span)
+      @mutex.synchronize do
+        @finished_spans += 1
+        # Current span is only meaningful for linear tree-like traces,
+        # in other cases, this is just broken and one should rely
+        # on per-instrumentation code to retrieve handle parent/child relations.
+        @current_span = span.parent
+        return if span.tracer.nil?
+        return unless Datadog::Tracer.debug_logging
+        if span.parent.nil? && !check_finished_spans
+          opened_spans = @trace.length - @finished_spans
+          Datadog::Tracer.log.debug("root span #{span.name} closed but has #{opened_spans} unfinished spans:")
+          @trace.each do |s|
+            Datadog::Tracer.log.debug("unfinished span: #{s}") unless s.finished?
+          end
+        end
+      end
+    end
+
+    # Returns if the trace for the current Context is finished or not.
+    # Low-level internal function, not thread-safe.
+    def check_finished_spans
+      @finished_spans > 0 && @trace.length == @finished_spans
+    end
+
+    # Returns if the trace for the current Context is finished or not. A \Context
+    # is considered finished if all spans in this context are finished.
+    def finished?
+      @mutex.synchronize do
+        return check_finished_spans
+      end
+    end
+
+    # Returns true if the context is sampled, that is, if it should be kept
+    # and sent to the trace agent.
+    def sampled?
+      @mutex.synchronize do
+        return @sampled
+      end
+    end
+
+    # Returns both the trace list generated in the current context and
+    # if the context is sampled or not. It returns nil, nil if the ``Context`` is
+    # not finished. If a trace is returned, the \Context will be reset so that it
+    # can be re-used immediately.
+    #
+    # This operation is thread-safe.
+    def get
+      @mutex.synchronize do
+        return nil, nil unless check_finished_spans
+
+        trace = @trace
+        sampled = @sampled
+        reset
+        return trace, sampled
+      end
+    end
+
+    # Return a string representation of the context.
+    def to_s
+      @mutex.synchronize do
+        # rubocop:disable Metrics/LineLength
+        "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
+      end
+    end
+
+    private :reset
+    private :check_finished_spans
+  end
+
+  # ThreadLocalContext can be used as a tracer global reference to create
+  # a different \Context for each thread. In synchronous tracer, this
+  # is required to prevent multiple threads sharing the same \Context
+  # in different executions.
+  class ThreadLocalContext
+    # ThreadLocalContext can be used as a tracer global reference to create
+    # a different \Context for each thread. In synchronous tracer, this
+    # is required to prevent multiple threads sharing the same \Context
+    # in different executions.
+    def initialize
+      self.local = Datadog::Context.new
+    end
+
+    # Override the thread-local context with a new context.
+    def local=(ctx)
+      Thread.current[:datadog_context] = ctx
+    end
+
+    # Return the thread-local context.
+    def local
+      Thread.current[:datadog_context] ||= Datadog::Context.new
+    end
+  end
+end