ls-trace 0.1.2 → 0.2.0

data/lib/ddtrace/tracer.rb

@@ -3,13 +3,13 @@ require 'thread'
 require 'logger'
 require 'pathname'
 
+require 'ddtrace/environment'
 require 'ddtrace/span'
 require 'ddtrace/context'
-require 'ddtrace/context_flush'
-require 'ddtrace/provider'
 require 'ddtrace/logger'
 require 'ddtrace/writer'
 require 'ddtrace/sampler'
+require 'ddtrace/sampling'
 require 'ddtrace/correlation'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
@@ -20,57 +20,17 @@ module Datadog
   # of these function calls and sub-requests would be encapsulated within a single trace.
   # rubocop:disable Metrics/ClassLength
   class Tracer
-    attr_reader :sampler, :tags, :provider
+    attr_reader :sampler, :tags, :provider, :context_flush
     attr_accessor :enabled, :writer
     attr_writer :default_service
 
     ALLOWED_SPAN_OPTIONS = [:service, :resource, :span_type].freeze
     DEFAULT_ON_ERROR = proc { |span, error| span.set_error(error) unless span.nil? }
 
-    # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
-    # namespace. This logger outputs to +STDOUT+ by default, and is considered thread-safe.
-    def self.log
-      unless defined? @logger
-        @logger = Datadog::Logger.new(STDOUT)
-        @logger.level = Logger::WARN
-      end
-      @logger
-    end
-
-    # Override the default logger with a custom one.
-    def self.log=(logger)
-      return unless logger
-      return unless logger.respond_to? :methods
-      return unless logger.respond_to? :error
-      if logger.respond_to? :methods
-        unimplemented = Logger.new(STDOUT).methods - logger.methods
-        unless unimplemented.empty?
-          logger.error("logger #{logger} does not implement #{unimplemented}")
-          return
-        end
-      end
-      @logger = logger
-    end
-
-    # Activate the debug mode providing more information related to tracer usage
-    # Default to Warn level unless using custom logger
-    def self.debug_logging=(value)
-      if value
-        log.level = Logger::DEBUG
-      elsif log.is_a?(Datadog::Logger)
-        log.level = Logger::WARN
-      end
-    end
-
-    # Return if the debug mode is activated or not
-    def self.debug_logging
-      log.level == Logger::DEBUG
-    end
-
     def services
       # Only log each deprecation warning once (safeguard against log spam)
       Datadog::Patcher.do_once('Tracer#set_service_info') do
-        Datadog::Tracer.log.warn('services: Usage of Tracer.services has been deprecated')
+        Datadog.logger.warn('services: Usage of Tracer.services has been deprecated')
       end
 
       {}
@@ -89,8 +49,9 @@ module Datadog
     #   tracer.shutdown!
     #
     def shutdown!
-      return if !@enabled || @writer.worker.nil?
-      @writer.worker.stop
+      return unless @enabled
+
+      @writer.stop unless @writer.nil?
     end
 
     # Return the current active \Context for this traced execution. This method is
@@ -109,17 +70,26 @@ module Datadog
     # * +enabled+: set if the tracer submits or not spans to the local agent. It's enabled
     #   by default.
     def initialize(options = {})
+      # Configurable options
+      @context_flush = if options[:partial_flush]
+                         Datadog::ContextFlush::Partial.new(options)
+                       else
+                         Datadog::ContextFlush::Finished.new
+                       end
+
+      @default_service = options[:default_service]
       @enabled = options.fetch(:enabled, true)
-      @writer = options.fetch(:writer, Datadog::Writer.new)
+      @provider = options.fetch(:context_provider, Datadog::DefaultContextProvider.new)
       @sampler = options.fetch(:sampler, Datadog::AllSampler.new)
+      @tags = options.fetch(:tags, {})
+      @writer = options.fetch(:writer, Datadog::Writer.new)
 
-      @provider = options.fetch(:context_provider, Datadog::DefaultContextProvider.new)
+      # Instance variables
+      @mutex = Mutex.new
       @provider ||= Datadog::DefaultContextProvider.new # @provider should never be nil
 
-      @context_flush = options[:partial_flush] ? Datadog::ContextFlush.new(options) : nil
-
-      @mutex = Mutex.new
-      @tags = {}
+      # Enable priority sampling by default
+      activate_priority_sampling!(@sampler)
     end
 
     # Updates the current \Tracer instance, so that the tracer can be configured after the
@@ -128,6 +98,7 @@ module Datadog
     # * +enabled+: set if the tracer submits or not spans to the trace agent
     # * +hostname+: change the location of the trace agent
     # * +port+: change the port of the trace agent
+    # * +partial_flush+: enable partial trace flushing
     #
     # For instance, if the trace agent runs in a different location, just:
     #
@@ -138,18 +109,19 @@ module Datadog
 
       # Those are rare "power-user" options.
       sampler = options.fetch(:sampler, nil)
-      max_spans_before_partial_flush = options.fetch(:max_spans_before_partial_flush, nil)
-      min_spans_before_partial_flush = options.fetch(:min_spans_before_partial_flush, nil)
-      partial_flush_timeout = options.fetch(:partial_flush_timeout, nil)
 
       @enabled = enabled unless enabled.nil?
       @sampler = sampler unless sampler.nil?
 
       configure_writer(options)
 
-      @context_flush = Datadog::ContextFlush.new(options) unless min_spans_before_partial_flush.nil? &&
-                                                                 max_spans_before_partial_flush.nil? &&
-                                                                 partial_flush_timeout.nil?
+      if options.key?(:partial_flush)
+        @context_flush = if options[:partial_flush]
+                           Datadog::ContextFlush::Partial.new(options)
+                         else
+                           Datadog::ContextFlush::Finished.new
+                         end
+      end
     end
 
     # Set the information about the given service. A valid example is:
@@ -160,7 +132,7 @@ module Datadog
     def set_service_info(service, app, app_type)
       # Only log each deprecation warning once (safeguard against log spam)
       Datadog::Patcher.do_once('Tracer#set_service_info') do
-        Datadog::Tracer.log.warn(%(
+        Datadog.logger.warn(%(
           set_service_info: Usage of set_service_info has been deprecated,
           service information no longer needs to be reported to the trace agent.
         ))
@@ -175,7 +147,7 @@ module Datadog
       begin
         @default_service = File.basename($PROGRAM_NAME, '.*')
       rescue StandardError => e
-        Datadog::Tracer.log.error("unable to guess default service: #{e}")
+        Datadog.logger.error("unable to guess default service: #{e}")
         @default_service = 'ruby'.freeze
       end
       @default_service
@@ -187,7 +159,8 @@ module Datadog
     #
     #   tracer.set_tags('env' => 'prod', 'component' => 'core')
     def set_tags(tags)
-      @tags.update(tags)
+      string_tags = Hash[tags.collect { |k, v| [k.to_s, v] }]
+      @tags = @tags.merge(string_tags)
     end
 
     # Guess context and parent from child_of entry.
@@ -239,8 +212,8 @@ module Datadog
         # child span
         span.parent = parent # sets service, trace_id, parent_id, sampled
       end
-      tags.each { |k, v| span.set_tag(k, v) } unless tags.empty?
-      @tags.each { |k, v| span.set_tag(k, v) } unless @tags.empty?
+      span.set_tags(@tags) unless @tags.empty?
+      span.set_tags(tags) unless tags.empty?
       span.start_time = start_time
 
       # this could at some point be optional (start_active_span vs start_manual_span)
@@ -282,9 +255,11 @@ module Datadog
     # * +service+: the service name for this span
     # * +resource+: the resource this span refers, or \name if it's missing
     # * +span_type+: the type of the span (such as \http, \db and so on)
+    # * +child_of+: a \Span or a \Context instance representing the parent for this span.
+    #   If not set, defaults to Tracer.call_context
     # * +tags+: extra tags which should be added to the span.
     def trace(name, options = {})
-      options[:child_of] = call_context
+      options[:child_of] ||= call_context
 
       # call the finish only if a block is given; this ensures
       # that a call to tracer.trace() without a block, returns
@@ -296,11 +271,16 @@ module Datadog
         begin
           begin
             span = start_span(name, options)
-          # rubocop:disable Lint/UselessAssignment
           rescue StandardError => e
-            Datadog::Tracer.log.debug('Failed to start span: #{e}')
+            Datadog.logger.debug("Failed to start span: #{e}")
           ensure
-            return_value = yield(span)
+            # We should yield to the provided block when possible, as this
+            # block is application code that we don't want to hinder. We call:
+            # * `yield(span)` during normal execution.
+            # * `yield(nil)` if `start_span` fails with a runtime error.
+            # * We don't yield during a fatal error, as the application is likely trying to
+            #   end its execution (either due to a system error or graceful shutdown).
+            return_value = yield(span) if span || e.is_a?(StandardError)
           end
         # rubocop:disable Lint/RescueException
         # Here we really want to catch *any* exception, not only StandardError,
@@ -328,24 +308,20 @@ module Datadog
     def record(context)
       context = context.context if context.is_a?(Datadog::Span)
       return if context.nil?
-      trace, sampled = context.get
-
-      # If context flushing is configured...
-      if @context_flush
-        if sampled
-          if trace.nil? || trace.empty?
-            @context_flush.each_partial_trace(context) do |t|
-              write(t)
-            end
-          else
-            write(trace)
-          end
-        end
-      # Default behavior
-      else
-        ready = !trace.nil? && !trace.empty? && sampled
-        write(trace) if ready
-      end
+
+      record_context(context)
+    end
+
+    # Consume trace from +context+, according to +@context_flush+
+    # criteria.
+    #
+    # \ContextFlush#consume! can return nil or an empty list if the
+    # trace is not available to flush or if the trace has not been
+    # chosen to be sampled.
+    def record_context(context)
+      trace = @context_flush.consume!(context)
+
+      write(trace) if @enabled && trace && !trace.empty?
     end
 
     # Return the current active span or +nil+.
@@ -366,13 +342,13 @@ module Datadog
     # Send the trace to the writer to enqueue the spans list in the agent
     # sending queue.
     def write(trace)
-      return if @writer.nil? || !@enabled
+      return if @writer.nil?
 
-      if Datadog::Tracer.debug_logging
-        Datadog::Tracer.log.debug("Writing #{trace.length} spans (enabled: #{@enabled})")
+      if Datadog.configuration.diagnostics.debug
+        Datadog.logger.debug("Writing #{trace.length} spans (enabled: #{@enabled})")
         str = String.new('')
         PP.pp(trace, str)
-        Datadog::Tracer.log.debug(str)
+        Datadog.logger.debug(str)
       end
 
       @writer.write(trace)
@@ -389,10 +365,10 @@ module Datadog
       sampler = options.fetch(:sampler, nil)
       priority_sampling = options.fetch(:priority_sampling, nil)
       writer = options.fetch(:writer, nil)
-      transport_options = options.fetch(:transport_options, {})
+      transport_options = options.fetch(:transport_options, {}).dup
 
       # Compile writer options
-      writer_options = options.fetch(:writer_options, {})
+      writer_options = options.fetch(:writer_options, {}).dup
       rebuild_writer = !writer_options.empty?
 
       # Re-build the sampler and writer if priority sampling is enabled,
@@ -441,7 +417,10 @@ module Datadog
       @sampler = if base_sampler.is_a?(PrioritySampler)
                    base_sampler
                  else
-                   PrioritySampler.new(base_sampler: base_sampler)
+                   PrioritySampler.new(
+                     base_sampler: base_sampler,
+                     post_sampler: Sampling::RuleSampler.new
+                   )
                  end
     end
 
@@ -454,6 +433,7 @@ module Datadog
       :configure_writer,
       :deactivate_priority_sampling!,
       :guess_context_and_parent,
+      :record_context,
       :write
   end
 end

data/lib/ddtrace/transport/http.rb

@@ -10,6 +10,7 @@ require 'ddtrace/transport/http/api'
 require 'ddtrace/transport/http/adapters/net'
 require 'ddtrace/transport/http/adapters/test'
 require 'ddtrace/transport/http/adapters/unix_socket'
+require 'uri'
 
 module Datadog
   module Transport
@@ -19,7 +20,7 @@ module Datadog
 
       # Builds a new Transport::HTTP::Client
       def new(&block)
-        Builder.new(&block).to_client
+        Builder.new(&block).to_transport
       end
 
       # Builds a new Transport::HTTP::Client with default settings
@@ -75,13 +76,27 @@ module Datadog
       end
 
       def default_hostname
+        return default_url.hostname if default_url
+
         ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_HOST, Datadog::Ext::Transport::HTTP::DEFAULT_HOST)
       end
 
       def default_port
+        return default_url.port if default_url
+
         ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_PORT, Datadog::Ext::Transport::HTTP::DEFAULT_PORT).to_i
       end
 
+      def default_url
+        url_env = ENV.fetch(Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL, nil)
+
+        if url_env
+          uri_parsed = URI.parse(url_env)
+
+          uri_parsed if %w[http https].include?(uri_parsed.scheme)
+        end
+      end
+
       # Add adapters to registry
       Builder::REGISTRY.set(Adapters::Net, :net_http)
       Builder::REGISTRY.set(Adapters::Test, :test)

data/lib/ddtrace/transport/http/adapters/net.rb

@@ -47,6 +47,10 @@ module Datadog
             Response.new(http_response)
           end
 
+          def url
+            "http://#{hostname}:#{port}?timeout=#{timeout}"
+          end
+
           # Raised when called with an unknown HTTP method
           class UnknownHTTPMethod < StandardError
             attr_reader :verb
@@ -104,6 +108,10 @@ module Datadog
               return super if http_response.nil?
               code.between?(500, 599)
             end
+
+            def inspect
+              "#{super}, http_response:#{http_response}"
+            end
           end
         end
       end

data/lib/ddtrace/transport/http/adapters/test.rb

@@ -33,6 +33,8 @@ module Datadog
             @status = status
           end
 
+          def url; end
+
           # Response for test adapter
           class Response
             include Datadog::Transport::Response
@@ -69,6 +71,10 @@ module Datadog
             def server_error?
               code.between?(500, 599)
             end
+
+            def inspect
+              "#{super}, code:#{code}"
+            end
           end
         end
       end

data/lib/ddtrace/transport/http/adapters/unix_socket.rb

@@ -31,6 +31,10 @@ module Datadog
             end
           end
 
+          def url
+            "http+unix://#{filepath}?timeout=#{timeout}"
+          end
+
           # Re-implements Net:HTTP with underlying Unix socket
           class HTTP < ::Net::HTTP
             DEFAULT_TIMEOUT = 1

data/lib/ddtrace/transport/http/api/instance.rb

@@ -15,6 +15,10 @@ module Datadog
             @headers = options.fetch(:headers, {})
           end
 
+          def encoder
+            spec.encoder
+          end
+
           def call(env)
             # Add headers to request env, unless empty.
             env.headers.merge!(headers) unless headers.empty?

data/lib/ddtrace/transport/http/builder.rb

@@ -70,13 +70,11 @@ module Datadog
           @default_api = key
         end
 
-        def to_client
+        def to_transport
           raise NoDefaultApiError if @default_api.nil?
 
-          @client ||= Client.new(
-            to_api_instances,
-            @default_api
-          )
+          # DEV: Should not be specific to traces
+          Transport::Traces::Transport.new(to_api_instances, @default_api)
         end
 
         def to_api_instances

data/lib/ddtrace/transport/http/client.rb

@@ -8,42 +8,31 @@ module Datadog
       class Client
         include Transport::HTTP::Statistics
 
-        attr_reader \
-          :apis,
-          :current_api_id
+        attr_reader :api
 
-        def initialize(apis, current_api_id)
-          @apis = apis
-
-          # Activate initial API
-          change_api!(current_api_id)
+        def initialize(api)
+          @api = api
         end
 
         def send_request(request, &block)
           # Build request into env
           env = build_env(request)
 
-          # Get response from API
-          response = yield(current_api, env)
+          # Get responses from API
+          response = yield(api, env)
 
           # Update statistics
           update_stats_from_response!(response)
 
-          # If API should be downgraded, downgrade and try again.
-          if downgrade?(response)
-            downgrade!
-            response = send_request(request, &block)
-          end
-
           response
         rescue StandardError => e
           message = "Internal error during HTTP transport request. Cause: #{e.message} Location: #{e.backtrace.first}"
 
           # Log error
           if stats.consecutive_errors > 0
-            Datadog::Tracer.log.debug(message)
+            Datadog.logger.debug(message)
           else
-            Datadog::Tracer.log.error(message)
+            Datadog.logger.error(message)
           end
 
           # Update statistics
@@ -55,52 +44,6 @@ module Datadog
         def build_env(request)
           Env.new(request)
         end
-
-        def downgrade?(response)
-          return false unless apis.fallbacks.key?(current_api_id)
-          response.not_found? || response.unsupported?
-        end
-
-        def current_api
-          apis[current_api_id]
-        end
-
-        def change_api!(api_id)
-          raise UnknownApiVersionError, api_id unless apis.key?(api_id)
-          @current_api_id = api_id
-        end
-
-        def downgrade!
-          downgrade_api_id = apis.fallbacks[current_api_id]
-          raise NoDowngradeAvailableError, current_api_id if downgrade_api_id.nil?
-          change_api!(downgrade_api_id)
-        end
-
-        # Raised when configured with an unknown API version
-        class UnknownApiVersionError < StandardError
-          attr_reader :version
-
-          def initialize(version)
-            @version = version
-          end
-
-          def message
-            "No matching transport API for version #{version}!"
-          end
-        end
-
-        # Raised when configured with an unknown API version
-        class NoDowngradeAvailableError < StandardError
-          attr_reader :version
-
-          def initialize(version)
-            @version = version
-          end
-
-          def message
-            "No downgrade from transport API version #{version} is available!"
-          end
-        end
       end
     end
   end