ddtrace 0.34.1 → 0.36.0

data/ddtrace.gemspec

@@ -47,12 +47,14 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rspec-collection_matchers', '~> 1.1'
   spec.add_development_dependency 'minitest', '= 5.10.1'
   spec.add_development_dependency 'appraisal', '~> 2.2'
-  spec.add_development_dependency 'bundler', '<= 2.1.2' # Remove when https://github.com/thoughtbot/appraisal/issues/162 is fixed
   spec.add_development_dependency 'yard', '~> 0.9'
   spec.add_development_dependency 'webmock', '~> 2.0'
   spec.add_development_dependency 'builder'
-  spec.add_development_dependency 'ruby-prof'
-  spec.add_development_dependency 'sqlite3', '~> 1.3.6'
+  if RUBY_PLATFORM != 'java'
+    spec.add_development_dependency 'sqlite3', '~> 1.3.6'
+  else
+    spec.add_development_dependency 'jdbc-sqlite3', '~> 3'
+  end
   spec.add_development_dependency 'climate_control', '~> 0.2.0'
 
   # locking transitive dependency of webmock

data/docker-compose.yml

@@ -1,5 +1,6 @@
 version: '3.2'
 services:
+  # MRI
   tracer-2.0:
     image: palazzem/docker-library:ddtrace_rb_2_0_0
     command: /bin/bash
@@ -247,6 +248,38 @@ services:
       - .:/app
       - bundle-2.7:/usr/local/bundle
       - gemfiles-2.7:/app/gemfiles
+  # JRuby
+  tracer-jruby-9.2:
+    image: marcotc/docker-library:ddtrace_rb_jruby_9_2
+    command: /bin/bash
+    depends_on:
+      - ddagent
+      - elasticsearch
+      - memcached
+      - mongodb
+      - mysql
+      - postgres
+      - presto
+      - redis
+    env_file: ./.env
+    environment:
+      - BUNDLE_GEMFILE=/app/Gemfile
+      - DD_AGENT_HOST=ddagent
+      - TEST_DATADOG_INTEGRATION=1
+      - TEST_ELASTICSEARCH_HOST=elasticsearch
+      - TEST_MEMCACHED_HOST=memcached
+      - TEST_MONGODB_HOST=mongodb
+      - TEST_MYSQL_HOST=mysql
+      - TEST_POSTGRES_HOST=postgres
+      - TEST_PRESTO_HOST=presto
+      - TEST_PRESTO_PORT=8080
+      - TEST_REDIS_HOST=redis
+    stdin_open: true
+    tty: true
+    volumes:
+      - .:/app
+      - bundle-jruby-9.2:/usr/local/bundle
+      - gemfiles-jruby-9.2:/app/gemfiles
   ddagent:
     image: datadog/docker-dd-agent
     environment:
@@ -325,6 +358,7 @@ volumes:
   bundle-2.5:
   bundle-2.6:
   bundle-2.7:
+  bundle-jruby-9.2:
   gemfiles-2.0:
   gemfiles-2.1:
   gemfiles-2.2:
@@ -333,3 +367,4 @@ volumes:
   gemfiles-2.5:
   gemfiles-2.6:
   gemfiles-2.7:
+  gemfiles-jruby-9.2:

data/docs/DevelopmentGuide.md

@@ -183,7 +183,7 @@ Then pass an adapter instance to the tracer configuration:
 
 ```ruby
 Datadog.configure do |c|
-  c.tracer transport_options: proc { |t|
+  c.tracer.transport_options = proc { |t|
     # By name
     t.adapter :custom
 

data/docs/GettingStarted.md

@@ -92,7 +92,7 @@ To contribute, check out the [contribution guidelines][contribution docs] and [d
 |       |                            | 2.0     | Full                                 | Latest              |
 |       |                            | 1.9.3   | Maintenance (until August 6th, 2020) | < 0.27.0            |
 |       |                            | 1.9.1   | Maintenance (until August 6th, 2020) | < 0.27.0            |
-| JRuby | http://jruby.org/          | 9.1.5   | Alpha                                | Latest              |
+| JRuby | http://jruby.org/          | 9.2.0.0 | Alpha                                | Latest              |
 
 **Supported web servers**:
 
@@ -771,7 +771,7 @@ Datadog.configure do |c|
   end
 end
 
-# Configure Faraday tracing behavior for single connection
+# In case you want to override the global configuration for a certain client instance
 connection = Faraday.new('https://example.com') do |builder|
   builder.use(:ddtrace, options)
   builder.adapter Faraday.default_adapter
@@ -1498,6 +1498,8 @@ The Sinatra integration traces requests and template rendering.
 
 To start using the tracing client, make sure you import `ddtrace` and `use :sinatra` after either `sinatra` or `sinatra/base`, and before you define your application/routes:
 
+#### Classic application
+
 ```ruby
 require 'sinatra'
 require 'ddtrace'
@@ -1511,7 +1513,40 @@ get '/' do
 end
 ```
 
-Where `options` is an optional `Hash` that accepts the following parameters:
+#### Modular application
+
+```ruby
+require 'sinatra/base'
+require 'ddtrace'
+
+Datadog.configure do |c|
+  c.use :sinatra, options
+end
+
+class NestedApp < Sinatra::Base
+  register Datadog::Contrib::Sinatra::Tracer
+
+  get '/nested' do
+    'Hello from nested app!'
+  end
+end
+
+class App < Sinatra::Base
+  register Datadog::Contrib::Sinatra::Tracer
+
+  use NestedApp
+
+  get '/' do
+    'Hello world!'
+  end
+end
+```
+
+Ensure you register `Datadog::Contrib::Sinatra::Tracer` as a middleware before you mount your nested applications.
+
+#### Instrumentation options
+
+`options` is an optional `Hash` that accepts the following parameters:
 
 | Key | Description | Default |
 | --- | ----------- | ------- |
@@ -1555,20 +1590,28 @@ To change the default behavior of the Datadog tracer, you can provide custom opt
 # config/initializers/datadog-tracer.rb
 
 Datadog.configure do |c|
-  c.tracer option_name: option_value, ...
+  c.tracer.enabled = true
+  c.tracer.hostname = 'my-agent'
+  c.tracer.port = 8126
+  c.tracer.partial_flush.enabled = false
+  c.tracer.sampler = Datadog::AllSampler.new
+
+  # OR for advanced use cases, you can specify your own tracer:
+  c.tracer.instance = Datadog::Tracer.new
+
+  # To enable debug mode:
+  c.diagnostics.debug = true
 end
 ```
 
 Available options are:
 
- - `enabled`: defines if the `tracer` is enabled or not. If set to `false` the code could be still instrumented because of other settings, but no spans are sent to the local trace agent.
- - `debug`: set to true to enable debug logging.
+ - `enabled`: defines if the `tracer` is enabled or not. If set to `false` instrumentation will still run, but no spans are sent to the trace agent.
  - `hostname`: set the hostname of the trace agent.
+ - `instance`: set to a custom `Datadog::Tracer` instance. If provided, other trace settings are ignored (you must configure it manually.)
+ - `partial_flush.enabled`: set to `true` to enable partial trace flushing (for long running traces.) Disabled by default. *Experimental.*
  - `port`: set the port the trace agent is listening on.
- - `env`: set the environment. Rails users may set it to `Rails.env` to use their application settings.
- - `tags`: set global tags that should be applied to all spans. Defaults to an empty hash
- - `log`: defines a custom logger.
- - `partial_flush`: set to `true` to enable partial trace flushing (for long running traces.) Disabled by default. *Experimental.*
+ - `sampler`: set to a custom `Datadog::Sampler` instance. If provided, the tracer will use this sampler to determine sampling behavior.
 
 #### Custom logging
 
@@ -1576,15 +1619,16 @@ By default, all logs are processed by the default Ruby logger. When using Rails,
 
 Datadog client log messages are marked with `[ddtrace]` so you should be able to isolate them from other messages.
 
-Additionally, it is possible to override the default logger and replace it by a custom one. This is done using the `log` attribute of the tracer.
+Additionally, it is possible to override the default logger and replace it by a custom one. This is done using the `log` setting.
 
 ```ruby
-f = File.new("my-custom.log", "w+")           # Log messages should go there
+f = File.new("my-custom.log", "w+") # Log messages should go there
 Datadog.configure do |c|
-  c.tracer log: Logger.new(f)                 # Overriding the default tracer
+  c.logger = Logger.new(f) # Overriding the default logger
+  c.logger.level = ::Logger::INFO
 end
 
-Datadog::Logger.log.info { "this is typically called by tracing code" }
+Datadog.logger.info { "this is typically called by tracing code" }
 ```
 
 ### Environment and tags
@@ -1594,9 +1638,11 @@ By default, the trace agent (not this library, but the program running in the ba
 You can configure the application to automatically tag your traces and metrics, using the following environment variables:
 
  - `DD_ENV`: Your application environment (e.g. `production`, `staging`, etc.)
+ - `DD_SERVICE`: Your application's default service name (e.g. `billing-api`)
  - `DD_VERSION`: Your application version (e.g. `2.5`, `202003181415`, `1.3-alpha`, etc.)
  - `DD_TAGS`: Custom tags in value pairs separated by `,` (e.g. `layer:api,team:intake`)
-    - If `DD_ENV` or `DD_VERSION`, it will override any `env` or `version` tag defined in `DD_TAGS`.
+    - If `DD_ENV`, `DD_SERVICE` or `DD_VERSION` are set, it will override any respective `env`/`service`/`version` tag defined in `DD_TAGS`.
+    - If `DD_ENV`, `DD_SERVICE` or `DD_VERSION` are NOT set, tags defined in `DD_TAGS` will be used to populate `env`/`service`/`version` respectively.
 
 These values can also be overridden at the tracer level:
 
@@ -1609,9 +1655,9 @@ Datadog.configure do |c|
 end
 ```
 
-This enables you to set this value on a per tracer basis, so you can have for example several applications reporting for different environments on the same host.
+This enables you to set this value on a per application basis, so you can have for example several applications reporting for different environments on the same host.
 
-Ultimately, tags can be set per span, but `env` should typically be the same for all spans belonging to a given trace.
+Tags can also be set directly on individual spans, which will supersede any conflicting tags defined at the application level.
 
 ### Sampling
 
@@ -1622,8 +1668,9 @@ Ultimately, tags can be set per span, but `env` should typically be the same for
 ```ruby
 # Sample rate is between 0 (nothing sampled) to 1 (everything sampled).
 sampler = Datadog::RateSampler.new(0.5) # sample 50% of the traces
+
 Datadog.configure do |c|
-  c.tracer sampler: sampler
+  c.tracer.sampler = sampler
 end
 ```
 
@@ -1900,6 +1947,7 @@ Datadog.tracer.trace('correlation.example') do
   correlation.trace_id # => 5963550561812073440
   correlation.span_id # => 2232727802607726424
   correlation.env # => 'production' (derived from DD_ENV)
+  correlation.service # => 'billing-api' (derived from DD_SERVICE)
   correlation.version # => '2.5.17' (derived from DD_VERSION)
 end
 
@@ -1909,8 +1957,9 @@ correlation = Datadog.tracer.active_correlation
 correlation = Datadog.tracer.active_correlation
 correlation.trace_id # => 0
 correlation.span_id # => 0
-correlation.trace_id # => nil
-correlation.span_id # => nil
+correlation.env # => 'production' (derived from DD_ENV)
+correlation.service # => 'billing-api' (derived from DD_SERVICE)
+correlation.version # => '2.5.17' (derived from DD_VERSION)
 ```
 
 #### For logging in Rails applications using Lograge (recommended)
@@ -1929,6 +1978,7 @@ config.lograge.custom_options = lambda do |event|
       :trace_id => correlation.trace_id.to_s,
       :span_id => correlation.span_id.to_s,
       :env => correlation.env.to_s,
+      :service => correlation.service.to_s,
       :version => correlation.version.to_s
     },
     :ddsource => ["ruby"],
@@ -1950,27 +2000,29 @@ end
 
 # Given:
 # DD_ENV = 'production' (The name of the environment your application is running in.)
+# DD_SERVICE = 'billing-api' (Default service name of your application.)
 # DD_VERSION = '2.5.17' (The version of your application.)
 
 # Web requests will produce:
-# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206 dd.env=production dd.version=2.5.17] Started GET "/articles" for 172.22.0.1 at 2019-01-16 18:50:57 +0000
-# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206 dd.env=production dd.version=2.5.17] Processing by ArticlesController#index as */*
-# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206 dd.env=production dd.version=2.5.17]   Article Load (0.5ms)  SELECT "articles".* FROM "articles"
-# [dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206 dd.env=production dd.version=2.5.17] Completed 200 OK in 7ms (Views: 5.5ms | ActiveRecord: 0.5ms)
+# [dd.env=production dd.service=billing-api dd.version=2.5.17 dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206] Started GET "/articles" for 172.22.0.1 at 2019-01-16 18:50:57 +0000
+# [dd.env=production dd.service=billing-api dd.version=2.5.17 dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206] Processing by ArticlesController#index as */*
+# [dd.env=production dd.service=billing-api dd.version=2.5.17 dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206]   Article Load (0.5ms)  SELECT "articles".* FROM "articles"
+# [dd.env=production dd.service=billing-api dd.version=2.5.17 dd.trace_id=7110975754844687674 dd.span_id=7518426836986654206] Completed 200 OK in 7ms (Views: 5.5ms | ActiveRecord: 0.5ms)
 ```
 
 #### For logging in Ruby applications
 
 To add correlation IDs to your logger, add a log formatter which retrieves the correlation IDs with `Datadog.tracer.active_correlation`, then add them to the message.
 
-To properly correlate with Datadog logging, be sure the following is present in the log message:
+To properly correlate with Datadog logging, be sure the following is present in the log message, in order as they appear:
 
+ - `dd.env=<ENV>`: Where `<ENV>` is equal to `Datadog.tracer.active_correlation.env`. Omit if no environment is configured.
+ - `dd.service=<SERVICE>`: Where `<SERVICE>` is equal to `Datadog.tracer.active_correlation.service`. Omit if no default service name is configured.
+ - `dd.version=<VERSION>`: Where `<VERSION>` is equal to `Datadog.tracer.active_correlation.version`. Omit if no application version is configured.
  - `dd.trace_id=<TRACE_ID>`: Where `<TRACE_ID>` is equal to `Datadog.tracer.active_correlation.trace_id` or `0` if no trace is active during logging.
  - `dd.span_id=<SPAN_ID>`: Where `<SPAN_ID>` is equal to `Datadog.tracer.active_correlation.span_id` or `0` if no trace is active during logging.
- - `dd.env=<ENV>`: Where `<ENV>` is equal to `Datadog.tracer.active_correlation.env` or empty string (no quotes) if no environment name is configured.
- - `dd.version=<SPAN_ID>`: Where `<SPAN_ID>` is equal to `Datadog.tracer.active_correlation.version` or empty string (no quotes) if no application version is configured.
 
-By default, `Datadog::Correlation::Identifier#to_s` will return `dd.trace_id=<TRACE_ID> dd.span_id=<SPAN_ID> dd.env=<ENV> dd.version=<VERSION>`.
+By default, `Datadog::Correlation::Identifier#to_s` will return `dd.env=<ENV> dd.service=<SERVICE> dd.version=<VERSION> dd.trace_id=<TRACE_ID> dd.span_id=<SPAN_ID>`.
 
 If a trace is not active and the application environment & version is not configured, it will return `dd.trace_id=0 dd.span_id=0 dd.env= dd.version=`.
 
@@ -1981,6 +2033,7 @@ require 'ddtrace'
 require 'logger'
 
 ENV['DD_ENV'] = 'production'
+ENV['DD_SERVICE'] = 'billing-api'
 ENV['DD_VERSION'] = '2.5.17'
 
 logger = Logger.new(STDOUT)
@@ -1991,11 +2044,11 @@ end
 
 # When no trace is active
 logger.warn('This is an untraced operation.')
-# [2019-01-16 18:38:41 +0000][my_app][WARN][dd.trace_id=0 dd.span_id=0 dd.env=production dd.version=2.5.17] This is an untraced operation.
+# [2019-01-16 18:38:41 +0000][my_app][WARN][dd.env=production dd.service=billing-api dd.version=2.5.17 dd.trace_id=0 dd.span_id=0] This is an untraced operation.
 
 # When a trace is active
 Datadog.tracer.trace('my.operation') { logger.warn('This is a traced operation.') }
-# [2019-01-16 18:38:41 +0000][my_app][WARN][dd.trace_id=8545847825299552251 dd.span_id=3711755234730770098 dd.env=production dd.version=2.5.17] This is a traced operation.
+# [2019-01-16 18:38:41 +0000][my_app][WARN][dd.env=production dd.service=billing-api dd.version=2.5.17 dd.trace_id=8545847825299552251 dd.span_id=3711755234730770098] This is a traced operation.
 ```
 
 ### Configuring the transport layer
@@ -2010,7 +2063,7 @@ The `Net` adapter submits traces using `Net::HTTP` over TCP. It is the default t
 
 ```ruby
 Datadog.configure do |c|
-  c.tracer transport_options: proc do |t|
+  c.tracer.transport_options = proc { |t|
     # Hostname, port, and additional options. :timeout is in seconds.
     t.adapter :net_http, '127.0.0.1', 8126, { timeout: 1 }
   }
@@ -2025,7 +2078,7 @@ To use, first configure your trace agent to listen by Unix socket, then configur
 
 ```ruby
 Datadog.configure do |c|
-  c.tracer transport_options: proc { |t|
+  c.tracer.transport_options = proc { |t|
     # Provide filepath to trace agent Unix socket
     t.adapter :unix, '/tmp/ddagent/trace.sock'
   }
@@ -2038,7 +2091,7 @@ The `Test` adapter is a no-op transport that can optionally buffer requests. For
 
 ```ruby
 Datadog.configure do |c|
-  c.tracer transport_options: proc { |t|
+  c.tracer.transport_options = proc { |t|
     # Set transport to no-op mode. Does not retain traces.
     t.adapter :test
 
@@ -2055,7 +2108,7 @@ Custom adapters can be configured with:
 
 ```ruby
 Datadog.configure do |c|
-  c.tracer transport_options: proc { |t|
+  c.tracer.transport_options = proc { |t|
     # Initialize and pass an instance of the adapter
     custom_adapter = CustomAdapter.new
     t.adapter custom_adapter
@@ -2086,12 +2139,12 @@ require 'ddtrace'
 Datadog.configure do |c|
   # To enable runtime metrics collection, set `true`. Defaults to `false`
   # You can also set DD_RUNTIME_METRICS_ENABLED=true to configure this.
-  c.runtime_metrics_enabled = true
+  c.runtime_metrics.enabled = true
 
   # Optionally, you can configure the Statsd instance used for sending runtime metrics.
   # Statsd is automatically configured with default settings if `dogstatsd-ruby` is available.
   # You can configure with host and port of Datadog agent; defaults to 'localhost:8125'.
-  c.runtime_metrics statsd: Datadog::Statsd.new
+  c.runtime_metrics.statsd = Datadog::Statsd.new
 end
 ```
 

data/lib/ddtrace.rb

@@ -34,7 +34,7 @@ module Datadog
   # Add shutdown hook:
   # Ensures the tracer has an opportunity to flush traces
   # and cleanup before terminating the process.
-  at_exit { Datadog.tracer.shutdown! }
+  at_exit { Datadog.shutdown! }
 end
 
 require 'ddtrace/contrib/action_cable/integration'

data/lib/ddtrace/buffer.rb

@@ -83,7 +83,7 @@ module Datadog
       @buffer_accepted += 1
       @buffer_accepted_lengths += trace.length
     rescue StandardError => e
-      Datadog::Logger.log.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def measure_drop(trace)
@@ -91,21 +91,21 @@ module Datadog
       @buffer_spans -= trace.length
       @buffer_accepted_lengths -= trace.length
     rescue StandardError => e
-      Datadog::Logger.log.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.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)
+      Datadog.health_metrics.queue_accepted(@buffer_accepted)
+      Datadog.health_metrics.queue_accepted_lengths(@buffer_accepted_lengths)
 
       # Dropped
-      Diagnostics::Health.metrics.queue_dropped(@buffer_dropped)
+      Datadog.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)
+      Datadog.health_metrics.queue_max_length(@max_size)
+      Datadog.health_metrics.queue_spans(@buffer_spans)
+      Datadog.health_metrics.queue_length(traces.length)
 
       # Reset aggregated metrics
       @buffer_accepted = 0
@@ -113,7 +113,7 @@ module Datadog
       @buffer_dropped = 0
       @buffer_spans = 0
     rescue StandardError => e
-      Datadog::Logger.log.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
   end
 end

data/lib/ddtrace/chunker.rb

@@ -0,0 +1,34 @@
+require 'json'
+require 'msgpack'
+
+module Datadog
+  # Chunks list of elements into batches
+  module Chunker
+    module_function
+
+    # Chunks a list into batches of at most +max_chunk_size+ elements each.
+    #
+    # An exception can occur if a single element is too large. That single
+    # element will be returned in its own chunk. You have to verify by yourself
+    # when such elements are returned.
+    #
+    # @param list [Enumerable] list of elements
+    # @param max_chunk_size [Numeric] maximum acceptable chunk size
+    # @return [Enumerable] lazy list of chunks
+    def chunk_by_size(list, max_chunk_size)
+      chunk_agg = 0
+      list.slice_before do |elem|
+        size = elem.size
+        chunk_agg += size
+        if chunk_agg > max_chunk_size
+          # Can't fit element in current chunk, start a new one.
+          chunk_agg = size
+          true
+        else
+          # Add to current chunk
+          false
+        end
+      end
+    end
+  end
+end