ddtrace 0.23.3 → 0.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58499947435a908a1815f048025f181f4651c3ad
-  data.tar.gz: 615ab8677d1463ceacdd0e7fa75c7015eb0f3068
+  metadata.gz: 634a3b4b1798b771abe9af49ee6ac02c2b64a4bc
+  data.tar.gz: 8854e2a87b04f4aeaf426eb8320ce9f728565dd0
 SHA512:
-  metadata.gz: 26db8434fb7515336f1db628f76e9e6e04f0a8f6fa1c74a5e1206e8045c6e4b058805cbd3526f41e7f1ce7076122b3ae601f37a52db81b0c556f04be48240922
-  data.tar.gz: c4ef32d8dbf2aac5629fce033d22acc08808c4ffffa907de0e4c534bce8c2fbbe6dea7790f49cf92e480e31263f3964f534eea25ca49303336b03c94eb79956f
+  metadata.gz: a816feb5c86306091e2bf300dc2219f9a6c60cb08e41643bfba4f8a4a5832623c2677eedf48778d40a4557b31fe53dc456f8793f02035cca7dc2115fae909e5c
+  data.tar.gz: 203406fe03985bfda50aeb2e886251b74672f066cb43765bbd06450ab6c86d5a98493691876f3cfb8fc1ca69a426276ae770851e39b96a122c2060c2c5ad938e

data/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 ## [Unreleased (beta)]
 
+## [0.24.0] - 2019-05-21
+
+Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.24.0
+
+Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.23.3...v0.24.0
+
+### Added
+
+- B3 header support (#753)
+- Hostname tagging option (#760)
+- Contribution and development guides (#754)
+
 ## [0.23.3] - 2019-05-16
 
 Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.23.3

data/CONTRIBUTING.md

@@ -0,0 +1,85 @@
+# Contributing
+
+Community contributions to the Datadog tracing library for Ruby are welcome! See below for some basic guidelines.
+
+## Want to request a new feature?
+
+Many great ideas for new features come from the community, and we'd be happy to consider yours!
+
+To share your request, you can [open a Github issue](https://github.com/DataDog/dd-trace-rb/issues/new) with the details about what you'd like to see. At a minimum, please provide:
+
+ - The goal of the new feature
+ - A description of how it might be used or behave
+ - Links to any important resources (e.g. Github repos, websites, screenshots, specifications, diagrams)
+
+Additionally, if you can, include:
+
+ - A description of how it could be accomplished
+ - Code snippets that might demonstrate its use or implementation
+ - Screenshots or mockups that visually demonstrate the feature
+ - Links to similar features that would serve as a good comparison
+ - (Any other details that would be useful for implementing this feature!)
+
+Feature requests will be reviewed, discussed, and then added to [our Community project](https://github.com/DataDog/dd-trace-rb/projects/2).
+
+## Found a bug?
+
+For any urgent matters (such as outages) or issues concerning the Datadog service or UI, contact our support team via https://docs.datadoghq.com/help/ for direct, faster assistance.
+
+You may submit bug reports concerning the Datadog tracing library for Ruby by [opening a Github issue](https://github.com/DataDog/dd-trace-rb/issues/new). At a minimum, please provide:
+
+ - A description of the problem
+ - Steps to reproduce
+ - Expected behavior
+ - Actual behavior
+ - Errors (with stack traces) or warnings received
+ - Any details you can share about your configuration including:
+    - Ruby version & platform
+    - `ddtrace` version
+    - Versions of any other relevant gems (or a `Gemfile.lock` if available)
+    - Any configuration settings for the trace library (e.g. `initializers/datadog.rb`)
+
+If at all possible, also provide:
+
+ - Logs (from the tracer/application/agent) or other diagnostics
+ - Screenshots, links, or other visual aids that are publicly accessible
+ - Code sample or test that reproduces the problem
+ - An explanation of what causes the bug and/or how it can be fixed
+
+Reports that include rich detail are better, and ones with code that reproduce the bug are best. Bug requests are triaged, reviewed, and added to [our Community project](https://github.com/DataDog/dd-trace-rb/projects/2).
+
+## Have a patch?
+
+We welcome code contributions to the library, which you can [submit as a pull request](https://github.com/DataDog/dd-trace-rb/pull/new/master). To create a pull request:
+
+1. **Fork the repository** from https://github.com/DataDog/dd-trace-rb
+2. **Make any changes** for your patch.
+3. **Write tests** that demonstrate how the feature works or how the bug is fixed.
+4. **Update any documentation** such as `docs/GettingStarted.md`, especially for new features.
+5. **Submit the pull request** from your fork back to https://github.com/DataDog/dd-trace-rb. Bugs should merge back to `master`, and new features should merge back to the latest `dev` branch (e.g. `0.24-dev`).
+
+The pull request will be run through our CI pipeline, and a project member will review the changes with you. At a minimum, to be accepted and merged, pull requests must:
+
+ - Have a stated goal and detailed description of the changes made
+ - Include thorough test coverage and documentation, where applicable
+ - Pass all tests and code quality checks (linting/coverage/benchmarks) on CI
+ - Receive at least one approval from a project member with push permissions
+
+We also recommend that you share in your description:
+
+ - Any motivations or intent for the contribution
+ - Links to any issues/pull requests it might be related to
+ - Links to any webpages or other external resources that might be related to the change
+ - Screenshots, code samples, or other visual aids that demonstrate the changes or how they are implemented
+ - Benchmarks if the feature is anticipated to have performance implications
+ - Any limitations, constraints or risks that are important to consider
+
+Pull requests will be reviewed and added to [our Community project](https://github.com/DataDog/dd-trace-rb/projects/2).
+
+For more information on common topics such as debugging locally, or how to write new integrations, check out [our development guide](https://github.com/DataDog/dd-trace-rb/docs/DevelopmentGuide.md). If at any point you have a question or need assistance with your pull request, feel free to mention a project member! We're always happy to help contributors with their pull requests.
+
+## Final word
+
+Many thanks to all of our contributors, and looking forward to seeing you on Github! :tada:
+
+ - Datadog Ruby APM Team

data/README.md

@@ -13,41 +13,11 @@ For installation, configuration, and details about using the API, check out our
 
 For descriptions of terminology used in APM, take a look at the [official documentation][visualization docs].
 
+For contributing, checkout the [contribution guidelines][contribution docs] and [development guide][development docs].
+
 [setup docs]: https://docs.datadoghq.com/tracing/setup/ruby/
 [api docs]: https://github.com/DataDog/dd-trace-rb/blob/master/docs/GettingStarted.md
 [gem docs]: http://gems.datadoghq.com/trace/docs/
 [visualization docs]: https://docs.datadoghq.com/tracing/visualization/
-
-## Development
-
-### Testing
-
-Configure your environment through:
-
-    $ bundle install
-    $ appraisal install
-
-You can launch tests using the following Rake commands:
-
-    $ rake test:main                                      # tracer tests
-    $ appraisal rails<version>-<database> rake test:rails # tests Rails matrix
-    $ appraisal contrib rake test:redis                   # tests Redis integration
-    ...
-
-Run ``rake --tasks`` for the list of available Rake tasks.
-Run ``appraisal list`` for the list of available appraisals.
-
-The test suite requires many backing services (PostgreSQL, MySQL, Redis, ...) and we're using
-``docker`` and ``docker-compose`` to start these services in the CI.
-To launch properly the test matrix, please [install docker][2] and [docker-compose][3] using
-the instructions provided by your platform. Then launch them through:
-
-    $ docker-compose up -d
-
-We also enforce the Ruby [community-driven style guide][1] through Rubocop. Simply launch:
-
-    $ rake rubocop
-
-[1]: https://github.com/bbatsov/ruby-style-guide
-[2]: https://www.docker.com/products/docker
-[3]: https://www.docker.com/products/docker-compose
+[contribution docs]: https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md
+[development docs]: https://github.com/DataDog/dd-trace-rb/blob/master/docs/DevelopmentGuide.md

data/docs/DevelopmentGuide.md

@@ -0,0 +1,132 @@
+# Developing
+
+This guide covers some of the common how-tos and technical reference material for developing changes within the trace library.
+
+## Table of Contents
+
+ - [Setting up](#setting-up)
+ - [Testing](#testing)
+     - [Writing tests](#writing-tests)
+     - [Running tests](#running-tests)
+     - [Checking code quality](#checking-code-quality)
+ - [Appendix](#appendix)
+     - [Writing new integrations](#writing-new-integrations)
+
+## Setting up
+
+*NOTE: To test locally, you must have `Docker` and `Docker Compose` installed. See the [Docker documentation](https://docs.docker.com/compose/install/) for details.*
+
+The trace library uses Docker Compose to create a Ruby environment to develop and test within, as well as containers for any dependencies that might be necessary for certain kinds of tests.
+
+To start a development environment, choose a target Ruby version (e.g. between `1.9` and `2.4`) then run the following:
+
+```
+# In the root directory of the project...
+cd ~/dd-trace-rb
+
+# Create and start a Ruby 2.3 test environment with its dependencies
+docker-compose run --rm tracer-2.3 /bin/bash
+
+# Then inside the container (e.g. `root@2a73c6d8673e:/app`)...
+# Install the library dependencies
+bundle install
+
+# Install build targets
+appraisal install
+```
+
+Then within this container you can [run tests](#running-tests), or [run code quality checks](#checking-code-quality).
+
+## Testing
+
+The test suite uses both [Minitest](https://github.com/seattlerb/minitest) and [RSpec](https://rspec.info/) tests to verify the correctness of both the core trace library and its integrations.
+
+Minitest is deprecated in favor of RSpec; all new tests should be written in RSpec, and only existing minitests should be updated.
+
+### Writing tests
+
+New tests should be written as RSpec tests in the `spec/ddtrace` folder. Test files should generally mirror the structure of `lib`.
+
+All changes should be covered by a corresponding RSpec tests. Unit tests are preferred, and integration tests are accepted where appropriate (e.g. acceptance tests, verifying compatibility with datastores, etc) but should be kept to a minimum.
+
+**Considerations for CI**
+
+All tests should run in CI. When adding new `spec.rb` files, you may need to add a test task to ensure your test file is run in CI.
+
+ - Ensure that there is a corresponding Rake task defined in `Rakefile` under the the `spec` namespace, whose pattern matches your test file.
+ - Verify the Rake task is configured to run for the appropriate Ruby runtimes in the `ci` Rake task.
+
+### Running tests
+
+Simplest way to run tests is to run `bundle exec rake ci`, which will run the entire test suite, just as CI does.
+
+**For the core library**
+
+Run the tests for the core library with:
+
+```
+# Run Minitest
+$ bundle exec rake test:main
+# Run RSpec
+$ bundle exec rake spec:main
+```
+
+**For integrations**
+
+Integrations which interact with dependencies not listed in the `ddtrace` gemspec will need to load these dependencies to run their tests.
+
+To do so, load the dependencies using [Appraisal](https://github.com/thoughtbot/appraisal). You can see a list of available appraisals with `bundle exec appraisal list`, or examine the `Appraisals` file.
+
+Then to run tests, prefix the test commain with the appraisal. For example:
+
+```
+# Runs tests for Rails 3.2 + Postgres
+$ bundle exec appraisal rails32-postgres spec:rails
+# Runs tests for Redis
+$ bundle exec appraisal contrib rake spec:redis
+```
+
+**Passing arguments to tests**
+
+When running RSpec tests, you may pass additional args as parameters to the Rake task. For example:
+
+```
+# Runs Redis tests with seed 1234
+$ bundle exec appraisal contrib rake spec:redis'[--seed,1234]'
+```
+
+This can be useful for replicating conditions from CI or isolating certain tests.
+
+### Checking code quality
+
+**Linting**
+
+The trace library uses Rubocop to enforce [code style](https://github.com/bbatsov/ruby-style-guide) and quality. To check, run:
+
+```
+$ bundle exec rake rubocop
+```
+
+## Appendix
+
+### Writing new integrations
+
+Integrations are extensions to the trace library that add support for external dependencies (gems); they typically add auto-instrumentation to popular gems and frameworks. You will find many of our integrations in the `contrib` folder.
+
+Some general guidelines for adding new integrations:
+
+ - An integration can either be added directly to `dd-trace-rb`, or developed as its own gem that depends on `ddtrace`.
+ - Integrations should implement the configuration API for easy, consistent implementation. (See existing integrations as examples of this.)
+ - All new integrations require documentation, unit/integration tests written in RSpec, and passing CI builds.
+ - It's highly encouraged to share screenshots or other demos of how the new integration looks and works.
+
+To get started quickly, it's perfectly fine to copy-paste an existing integration to use as a template, then modify it to match your needs. This is usually the fastest, easiest way to bootstrap a new integration and makes the time-to-first-trace often very quick, usually less than an hour if it's a simple implementation.
+
+Once you have it working in your application, you can [add unit tests](#writing-tests), [run them locally](#running-tests), and [check for code quality](#checking-code-quality) using Docker Compose.
+
+Then [open a pull request](https://github.com/DataDog/dd-trace-rb/CONTRIBUTING.md#have-a-patch) and be sure to add the following to the description:
+
+ - [Documentation](https://github.com/DataDog/dd-trace-rb/docs/GettingStarted.md) for the integration, including versions supported.
+ - Links to the repository/website of the library being integrated
+ - Screenshots showing a sample trace
+ - Any additional code snippets, sample apps, benchmarks, or other resources that demonstrate its implementation are a huge plus!

data/docs/GettingStarted.md

@@ -11,9 +11,13 @@ For details about contributing, check out the [development guide][development do
 
 For descriptions of terminology used in APM, take a look at the [official documentation][visualization docs].
 
+For contributing, checkout the [contribution guidelines][contribution docs] and [development guide][development docs].
+
 [setup docs]: https://docs.datadoghq.com/tracing/setup/ruby/
 [development docs]: https://github.com/DataDog/dd-trace-rb/blob/master/README.md#development
 [visualization docs]: https://docs.datadoghq.com/tracing/visualization/
+[contribution docs]: https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md
+[development docs]: https://github.com/DataDog/dd-trace-rb/blob/master/docs/DevelopmentGuide.md
 
 ## Table of Contents
 

data/lib/ddtrace/configuration/settings.rb

@@ -1,4 +1,5 @@
 require 'ddtrace/ext/analytics'
+require 'ddtrace/ext/distributed'
 require 'ddtrace/ext/runtime'
 require 'ddtrace/configuration/options'
 
@@ -17,10 +18,32 @@ module Datadog
               default: -> { env_to_bool(Ext::Analytics::ENV_TRACE_ANALYTICS_ENABLED, nil) },
               lazy: true
 
+      option  :report_hostname,
+              default: -> { env_to_bool(Ext::NET::ENV_REPORT_HOSTNAME, false) },
+              lazy: true
+
       option  :runtime_metrics_enabled,
               default: -> { env_to_bool(Ext::Runtime::Metrics::ENV_ENABLED, false) },
               lazy: true
 
+      # Look for all headers by default
+      option  :propagation_extract_style,
+              default: lambda {
+                env_to_list(Ext::DistributedTracing::PROPAGATION_EXTRACT_STYLE_ENV,
+                            [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG,
+                             Ext::DistributedTracing::PROPAGATION_STYLE_B3,
+                             Ext::DistributedTracing::PROPAGATION_STYLE_B3_SINGLE_HEADER])
+              },
+              lazy: true
+
+      # Only inject Datadog headers by default
+      option  :propagation_inject_style,
+              default: lambda {
+                env_to_list(Ext::DistributedTracing::PROPAGATION_INJECT_STYLE_ENV,
+                            [Ext::DistributedTracing::PROPAGATION_STYLE_DATADOG])
+              },
+              lazy: true
+
       option :tracer, default: Tracer.new
 
       def initialize(options = {})
@@ -36,6 +59,12 @@ module Datadog
         yield(self) if block_given?
       end
 
+      def distributed_tracing
+        # TODO: Move distributed tracing configuration to it's own Settings sub-class
+        # DEV: We do this to fake `Datadog.configuration.distributed_tracing.propagation_inject_style`
+        self
+      end
+
       def runtime_metrics(options = nil)
         runtime_metrics = get_option(:tracer).writer.runtime_metrics
         return runtime_metrics if options.nil?

data/lib/ddtrace/distributed_tracing/headers/b3.rb

@@ -0,0 +1,44 @@
+require 'ddtrace/ext/distributed'
+require 'ddtrace/distributed_tracing/headers/headers'
+require 'ddtrace/distributed_tracing/headers/helpers'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # B3 provides helpers to inject or extract headers for B3 style headers
+      module B3
+        include Ext::DistributedTracing
+
+        def self.inject!(context, env)
+          return if context.nil?
+
+          # DEV: We need these to be hex encoded
+          env[B3_HEADER_TRACE_ID] = context.trace_id.to_s(16)
+          env[B3_HEADER_SPAN_ID] = context.span_id.to_s(16)
+
+          unless context.sampling_priority.nil?
+            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
+            env[B3_HEADER_SAMPLED] = sampling_priority.to_s
+          end
+        end
+
+        def self.extract(env)
+          # Extract values from headers
+          # DEV: B3 doesn't have "origin"
+          headers = Headers.new(env)
+          trace_id = headers.id(B3_HEADER_TRACE_ID, 16)
+          span_id = headers.id(B3_HEADER_SPAN_ID, 16)
+          # We don't need to try and convert sampled since B3 supports 0/1 (AUTO_REJECT/AUTO_KEEP)
+          sampling_priority = headers.number(B3_HEADER_SAMPLED)
+
+          # Return early if this propagation is not valid
+          return unless trace_id && span_id
+
+          ::Datadog::Context.new(trace_id: trace_id,
+                                 span_id: span_id,
+                                 sampling_priority: sampling_priority)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/b3_single.rb

@@ -0,0 +1,56 @@
+require 'ddtrace/ext/distributed'
+require 'ddtrace/distributed_tracing/headers/headers'
+require 'ddtrace/distributed_tracing/headers/helpers'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # B3Single provides helpers to inject or extract headers for B3 single header style headers
+      module B3Single
+        include Ext::DistributedTracing
+
+        def self.inject!(context, env)
+          return if context.nil?
+
+          # Header format:
+          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
+          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
+          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
+
+          # DEV: We need these to be hex encoded
+          header = "#{context.trace_id.to_s(16)}-#{context.span_id.to_s(16)}"
+
+          unless context.sampling_priority.nil?
+            sampling_priority = DistributedTracing::Headers::Helpers.clamp_sampling_priority(context.sampling_priority)
+            header += "-#{sampling_priority}"
+          end
+
+          env[B3_HEADER_SINGLE] = header
+        end
+
+        def self.extract(env)
+          # Header format:
+          #   b3: {TraceId}-{SpanId}-{SamplingState}-{ParentSpanId}
+          # https://github.com/apache/incubator-zipkin-b3-propagation/tree/7c6e9f14d6627832bd80baa87ac7dabee7be23cf#single-header
+          # DEV: `{SamplingState}` and `{ParentSpanId`}` are optional
+
+          headers = Headers.new(env)
+          value = headers.header(B3_HEADER_SINGLE)
+          return if value.nil?
+
+          parts = value.split('-')
+          trace_id = headers.value_to_id(parts[0], 16) unless parts.empty?
+          span_id = headers.value_to_id(parts[1], 16) if parts.length > 1
+          sampling_priority = headers.value_to_number(parts[2]) if parts.length > 2
+
+          # Return early if this propagation is not valid
+          return unless trace_id && span_id
+
+          ::Datadog::Context.new(trace_id: trace_id,
+                                 span_id: span_id,
+                                 sampling_priority: sampling_priority)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/datadog.rb

@@ -0,0 +1,42 @@
+require 'ddtrace/ext/distributed'
+require 'ddtrace/distributed_tracing/headers/headers'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # Datadog provides helpers to inject or extract headers for Datadog style headers
+      module Datadog
+        include Ext::DistributedTracing
+
+        def self.inject!(context, env)
+          return if context.nil?
+
+          env[HTTP_HEADER_TRACE_ID] = context.trace_id.to_s
+          env[HTTP_HEADER_PARENT_ID] = context.span_id.to_s
+          env[HTTP_HEADER_SAMPLING_PRIORITY] = context.sampling_priority.to_s unless context.sampling_priority.nil?
+          env[HTTP_HEADER_ORIGIN] = context.origin.to_s unless context.origin.nil?
+        end
+
+        def self.extract(env)
+          # Extract values from headers
+          headers = Headers.new(env)
+          trace_id = headers.id(HTTP_HEADER_TRACE_ID)
+          parent_id = headers.id(HTTP_HEADER_PARENT_ID)
+          origin = headers.header(HTTP_HEADER_ORIGIN)
+          sampling_priority = headers.number(HTTP_HEADER_SAMPLING_PRIORITY)
+
+          # Return early if this propagation is not valid
+          # DEV: To be valid we need to have a trace id and a parent id or when it is a synthetics trace, just the trace id
+          # DEV: `DistributedHeaders#id` will not return 0
+          return unless (trace_id && parent_id) || (origin == 'synthetics' && trace_id)
+
+          # Return new context
+          ::Datadog::Context.new(trace_id: trace_id,
+                                 span_id: parent_id,
+                                 origin: origin,
+                                 sampling_priority: sampling_priority)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/headers.rb

@@ -0,0 +1,68 @@
+require 'ddtrace/configuration'
+require 'ddtrace/span'
+require 'ddtrace/ext/distributed'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # Headers provides easy access and validation methods for Rack headers
+      class Headers
+        include Ext::DistributedTracing
+
+        def initialize(env)
+          @env = env
+        end
+
+        def header(name)
+          rack_header = "http-#{name}".upcase!.tr('-', '_')
+
+          hdr = @env[rack_header]
+
+          # Only return the value if it is not an empty string
+          hdr if hdr != ''
+        end
+
+        def id(hdr, base = 10)
+          value_to_id(header(hdr), base)
+        end
+
+        def value_to_id(value, base = 10)
+          id = value_to_number(value, base)
+
+          # Return early if we could not parse a number
+          return if id.nil?
+
+          # Zero or greater than max allowed value of 2**64
+          return if id.zero? || id > Span::EXTERNAL_MAX_ID
+          id < 0 ? id + (2**64) : id
+        end
+
+        def number(hdr, base = 10)
+          value_to_number(header(hdr), base)
+        end
+
+        def value_to_number(value, base = 10)
+          # It's important to make a difference between no header,
+          # and a header defined to zero.
+          return if value.nil?
+
+          # Be sure we have a string
+          value = value.to_s
+
+          # If we are parsing base16 number then truncate to 64-bit
+          value = DistributedTracing::Headers::Helpers.truncate_base16_number(value) if base == 16
+
+          # Convert header to an integer
+          # DEV: Ruby `.to_i` will return `0` if a number could not be parsed
+          num = value.to_i(base)
+
+          # Ensure the parsed number is the same as the original string value
+          # e.g. We want to make sure to throw away `'nan'.to_i == 0`
+          return unless num.to_s(base) == value
+
+          num
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/distributed_tracing/headers/helpers.rb

@@ -0,0 +1,45 @@
+require 'ddtrace/configuration'
+require 'ddtrace/span'
+require 'ddtrace/ext/priority'
+
+module Datadog
+  module DistributedTracing
+    module Headers
+      # Helpers module provides common helper functions for distributed tracing headers
+      module Helpers
+        # Base provides common methods for distributed header helper classes
+        def self.clamp_sampling_priority(sampling_priority)
+          # B3 doesn't have our -1 (USER_REJECT) and 2 (USER_KEEP) priorities so convert to acceptable 0/1
+          if sampling_priority < 0
+            sampling_priority = Ext::Priority::AUTO_REJECT
+          elsif sampling_priority > 1
+            sampling_priority = Ext::Priority::AUTO_KEEP
+          end
+
+          sampling_priority
+        end
+
+        def self.truncate_base16_number(value)
+          # Lowercase if we want to parse base16 e.g. 3E8 => 3e8
+          # DEV: Ruby will parse `3E8` just fine, but to test
+          #      `num.to_s(base) == value` we need to lowercase
+          value = value.downcase
+
+          # Truncate to trailing 16 characters if length is greater than 16
+          # https://github.com/apache/incubator-zipkin/blob/21fe362899fef5c593370466bc5707d3837070c2/zipkin/src/main/java/zipkin2/storage/StorageComponent.java#L49-L53
+          # DEV: This ensures we truncate B3 128-bit trace and span ids to 64-bit
+          value = value[value.length - 16, 16] if value.length > 16
+
+          # Remove any leading zeros
+          # DEV: When we call `num.to_s(16)` later Ruby will not add leading zeros
+          #      for us so we want to make sure the comparision will work as expected
+          # DEV: regex, remove all leading zeros up until we find the last 0 in the string
+          #      or we find the first non-zero, this allows `'0000' -> '0'` and `'00001' -> '1'`
+          value = value.sub(/^0*(?=(0$)|[^0])/, '')
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/environment.rb

@@ -10,6 +10,14 @@ module Datadog
       def env_to_float(var, default = nil)
         ENV.key?(var) ? ENV[var].to_f : default
       end
+
+      def env_to_list(var, default = [])
+        if ENV.key?(var)
+          ENV[var].split(',').map(&:strip)
+        else
+          default
+        end
+      end
     end
   end
 end

data/lib/ddtrace/ext/distributed.rb

@@ -10,6 +10,19 @@ module Datadog
       HTTP_HEADER_ORIGIN = 'x-datadog-origin'.freeze
       ORIGIN_KEY = '_dd.origin'.freeze
 
+      # B3 headers used for distributed tracing
+      B3_HEADER_TRACE_ID = 'x-b3-traceid'.freeze
+      B3_HEADER_SPAN_ID = 'x-b3-spanid'.freeze
+      B3_HEADER_SAMPLED = 'x-b3-sampled'.freeze
+      B3_HEADER_SINGLE = 'b3'.freeze
+
+      # Distributed tracing propagation options
+      PROPAGATION_STYLE_DATADOG = 'Datadog'.freeze
+      PROPAGATION_STYLE_B3 = 'B3'.freeze
+      PROPAGATION_STYLE_B3_SINGLE_HEADER = 'B3 single header'.freeze
+      PROPAGATION_INJECT_STYLE_ENV = 'DD_PROPAGATION_INJECT_STYLE'.freeze
+      PROPAGATION_EXTRACT_STYLE_ENV = 'DD_PROPAGATION_EXTRACT_STYLE'.freeze
+
       # gRPC metadata keys for distributed tracing. https://github.com/grpc/grpc-go/blob/v1.10.x/Documentation/grpc-metadata.md
       GRPC_METADATA_TRACE_ID = 'x-datadog-trace-id'.freeze
       GRPC_METADATA_PARENT_ID = 'x-datadog-parent-id'.freeze

data/lib/ddtrace/ext/net.rb

@@ -1,6 +1,8 @@
 module Datadog
   module Ext
     module NET
+      ENV_REPORT_HOSTNAME = 'DD_TRACE_REPORT_HOSTNAME'.freeze
+      TAG_HOSTNAME = '_dd.hostname'.freeze
       TARGET_HOST = 'out.host'.freeze
       TARGET_PORT = 'out.port'.freeze
     end

data/lib/ddtrace/propagation/http_propagator.rb

@@ -1,36 +1,75 @@
+require 'ddtrace/configuration'
 require 'ddtrace/context'
 require 'ddtrace/ext/distributed'
-require 'ddtrace/propagation/distributed_headers'
+require 'ddtrace/ext/priority'
+require 'ddtrace/distributed_tracing/headers/b3'
+require 'ddtrace/distributed_tracing/headers/b3_single'
+require 'ddtrace/distributed_tracing/headers/datadog'
 
 module Datadog
   # HTTPPropagator helps extracting and injecting HTTP headers.
   module HTTPPropagator
     include Ext::DistributedTracing
 
+    PROPAGATION_STYLES = { PROPAGATION_STYLE_B3 => DistributedTracing::Headers::B3,
+                           PROPAGATION_STYLE_B3_SINGLE_HEADER => DistributedTracing::Headers::B3Single,
+                           PROPAGATION_STYLE_DATADOG => DistributedTracing::Headers::Datadog }.freeze
+
     # inject! popolates the env with span ID, trace ID and sampling priority
     def self.inject!(context, env)
       # Prevent propagation from being attempted if context provided is nil.
       if context.nil?
-        Datadog::Tracer.log.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
+        ::Datadog::Tracer.log.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
         return
       end
 
-      env[HTTP_HEADER_TRACE_ID] = context.trace_id.to_s
-      env[HTTP_HEADER_PARENT_ID] = context.span_id.to_s
-      env[HTTP_HEADER_SAMPLING_PRIORITY] = context.sampling_priority.to_s
-      env[HTTP_HEADER_ORIGIN] = context.origin.to_s if context.origin
-      env.delete(HTTP_HEADER_SAMPLING_PRIORITY) unless context.sampling_priority
+      # Inject all configured propagation styles
+      ::Datadog.configuration.propagation_inject_style.each do |style|
+        propagator = PROPAGATION_STYLES[style]
+        propagator.inject!(context, env) unless propagator.nil?
+      end
     end
 
     # extract returns a context containing the span ID, trace ID and
     # sampling priority defined in env.
     def self.extract(env)
-      headers = DistributedHeaders.new(env)
-      return Datadog::Context.new unless headers.valid?
-      Datadog::Context.new(trace_id: headers.trace_id,
-                           span_id: headers.parent_id,
-                           sampling_priority: headers.sampling_priority,
-                           origin: headers.origin)
+      context = nil
+      dd_context = nil
+
+      ::Datadog.configuration.propagation_extract_style.each do |style|
+        propagator = PROPAGATION_STYLES[style]
+        next if propagator.nil?
+
+        # Extract context
+        # DEV: `propagator.extract` will return `nil`, where `HTTPPropagator#extract` will not
+        extracted_context = propagator.extract(env)
+        # Skip this style if no valid headers were found
+        next if extracted_context.nil?
+
+        # Keep track of the Datadog extract context, we want to return
+        #   this one if we have one
+        dd_context = extracted_context if extracted_context && style == PROPAGATION_STYLE_DATADOG
+
+        # No previously extracted context, use the one we just extracted
+        if context.nil?
+          context = extracted_context
+        else
+          unless context.trace_id == extracted_context.trace_id && context.span_id == extracted_context.span_id
+            # Return an empty/new context if we have a mismatch in values extracted
+            msg = "#{context.trace_id} != #{extracted_context.trace_id} && " \
+                  "#{context.span_id} != #{extracted_context.span_id}"
+            ::Datadog::Tracer.log.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
+            # DEV: This will return from `self.extract` not this `each` block
+            return ::Datadog::Context.new
+          end
+        end
+      end
+
+      # Return the extracted context if we found one or else a new empty context
+      # Always return the Datadog context if one exists since it has more
+      #   information than the B3 headers e.g. origin, expanded priority
+      #   sampling values, etc
+      dd_context || context || ::Datadog::Context.new
     end
   end
 end

data/lib/ddtrace/runtime/socket.rb

@@ -0,0 +1,14 @@
+require 'socket'
+
+module Datadog
+  module Runtime
+    # For runtime identity
+    module Socket
+      module_function
+
+      def hostname
+        ::Socket.gethostname
+      end
+    end
+  end
+end

data/lib/ddtrace/sync_writer.rb

@@ -1,3 +1,5 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/runtime/socket'
 require 'ddtrace/runtime/metrics'
 
 module Datadog
@@ -44,7 +46,17 @@ module Datadog
 
     def flush_trace(trace)
       processed_traces = Pipeline.process!([trace])
+      inject_hostname!(processed_traces.first) if Datadog.configuration.report_hostname
       transport.send(:traces, processed_traces)
     end
+
+    def inject_hostname!(trace)
+      unless 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
   end
 end

data/lib/ddtrace/version.rb

@@ -1,8 +1,8 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 23
-    PATCH = 3
+    MINOR = 24
+    PATCH = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')

data/lib/ddtrace/writer.rb

@@ -1,3 +1,6 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/runtime/socket'
+
 require 'ddtrace/transport'
 require 'ddtrace/encoding'
 require 'ddtrace/workers'
@@ -70,6 +73,9 @@ module Datadog
     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
+
       code = transport.send(:traces, traces)
       status = !transport.server_error?(code)
       @traces_flushed += traces.length if status
@@ -126,6 +132,17 @@ module Datadog
 
     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 sampling_updater(action, response, api)
       return unless action == :traces && response.is_a?(Net::HTTPOK)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 0.23.3
+  version: 0.24.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-16 00:00:00.000000000 Z
+date: 2019-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -301,6 +301,7 @@ files:
 - ".yardopts"
 - Appraisals
 - CHANGELOG.md
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE
 - README.md
@@ -309,6 +310,7 @@ files:
 - benchmarks/sidekiq_test.rb
 - ddtrace.gemspec
 - docker-compose.yml
+- docs/DevelopmentGuide.md
 - docs/GettingStarted.md
 - lib/ddtrace.rb
 - lib/ddtrace/analytics.rb
@@ -516,6 +518,11 @@ files:
 - lib/ddtrace/contrib/sucker_punch/integration.rb
 - lib/ddtrace/contrib/sucker_punch/patcher.rb
 - lib/ddtrace/correlation.rb
+- lib/ddtrace/distributed_tracing/headers/b3.rb
+- lib/ddtrace/distributed_tracing/headers/b3_single.rb
+- lib/ddtrace/distributed_tracing/headers/datadog.rb
+- lib/ddtrace/distributed_tracing/headers/headers.rb
+- lib/ddtrace/distributed_tracing/headers/helpers.rb
 - lib/ddtrace/encoding.rb
 - lib/ddtrace/environment.rb
 - lib/ddtrace/error.rb
@@ -555,7 +562,6 @@ files:
 - lib/ddtrace/pipeline.rb
 - lib/ddtrace/pipeline/span_filter.rb
 - lib/ddtrace/pipeline/span_processor.rb
-- lib/ddtrace/propagation/distributed_headers.rb
 - lib/ddtrace/propagation/grpc_propagator.rb
 - lib/ddtrace/propagation/http_propagator.rb
 - lib/ddtrace/provider.rb
@@ -565,6 +571,7 @@ files:
 - lib/ddtrace/runtime/gc.rb
 - lib/ddtrace/runtime/identity.rb
 - lib/ddtrace/runtime/metrics.rb
+- lib/ddtrace/runtime/socket.rb
 - lib/ddtrace/runtime/thread_count.rb
 - lib/ddtrace/sampler.rb
 - lib/ddtrace/span.rb

data/lib/ddtrace/propagation/distributed_headers.rb

@@ -1,70 +0,0 @@
-require 'ddtrace/span'
-require 'ddtrace/ext/distributed'
-
-module Datadog
-  # DistributedHeaders provides easy access and validation to headers
-  class DistributedHeaders
-    include Ext::DistributedTracing
-
-    def initialize(env)
-      @env = env
-    end
-
-    def valid?
-      # Synthetics sends us `X-Datadog-Parent-Id: 0` which normally we would want
-      # to filter out, but is ok in this context since there is no parent from Synthetics
-      return true if origin == 'synthetics' && trace_id
-
-      # Sampling priority and origin are optional.
-      # DEV: We want to explicitly return true/false here
-      trace_id && parent_id ? true : false
-    end
-
-    def trace_id
-      id HTTP_HEADER_TRACE_ID
-    end
-
-    def parent_id
-      id HTTP_HEADER_PARENT_ID
-    end
-
-    def sampling_priority
-      hdr = header(HTTP_HEADER_SAMPLING_PRIORITY)
-
-      # It's important to make a difference between no header,
-      # and a header defined to zero.
-      return if hdr.nil?
-
-      # Convert header to an integer
-      value = hdr.to_i
-
-      # Ensure the parsed number is the same as the original string value
-      # e.g. We want to make sure to throw away `'nan'.to_i == 0`
-      # DEV: Ruby `.to_i` will return `0` if a number could not be parsed
-      return unless value.to_s == hdr.to_s
-
-      value
-    end
-
-    def origin
-      hdr = header(HTTP_HEADER_ORIGIN)
-      # Only return the value if it is not an empty string
-      hdr if hdr != ''
-    end
-
-    private
-
-    def header(name)
-      rack_header = "http-#{name}".upcase!.tr('-', '_')
-
-      @env[rack_header]
-    end
-
-    def id(header)
-      value = header(header).to_i
-      # Zero or greater than max allowed value of 2**64
-      return if value.zero? || value > Span::EXTERNAL_MAX_ID
-      value < 0 ? value + 0x1_0000_0000_0000_0000 : value
-    end
-  end
-end