ls-trace 0.1.1

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

@@ -0,0 +1,140 @@
+require 'json'
+
+require 'ddtrace/transport/traces'
+require 'ddtrace/transport/http/response'
+require 'ddtrace/transport/http/api/endpoint'
+
+module Datadog
+  module Transport
+    module HTTP
+      # HTTP transport behavior for traces
+      module Traces
+        # Response from HTTP transport for traces
+        class Response
+          include HTTP::Response
+          include Transport::Traces::Response
+
+          def initialize(http_response, options = {})
+            super(http_response)
+            @service_rates = options.fetch(:service_rates, nil)
+          end
+        end
+
+        # Extensions for HTTP client
+        module Client
+          def send_traces(traces)
+            request = Transport::Traces::Request.new(traces)
+
+            send_request(request) do |api, env|
+              api.send_traces(env)
+            end
+          end
+        end
+
+        module API
+          # Extensions for HTTP API Spec
+          module Spec
+            attr_reader :traces
+
+            def traces=(endpoint)
+              @traces = endpoint
+            end
+
+            def send_traces(env, &block)
+              raise NoTraceEndpointDefinedError, self if traces.nil?
+              traces.call(env, &block)
+            end
+
+            # Raised when traces sent but no traces endpoint is defined
+            class NoTraceEndpointDefinedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'No trace endpoint is defined for API specification!'
+              end
+            end
+          end
+
+          # Extensions for HTTP API Instance
+          module Instance
+            def send_traces(env)
+              raise TracesNotSupportedError, spec unless spec.is_a?(Traces::API::Spec)
+
+              spec.send_traces(env) do |request_env|
+                call(request_env)
+              end
+            end
+
+            # Raised when traces sent to API that does not support traces
+            class TracesNotSupportedError < StandardError
+              attr_reader :spec
+
+              def initialize(spec)
+                @spec = spec
+              end
+
+              def message
+                'Traces not supported for this API!'
+              end
+            end
+          end
+
+          # Endpoint for submitting trace data
+          class Endpoint < HTTP::API::Endpoint
+            HEADER_CONTENT_TYPE = 'Content-Type'.freeze
+            HEADER_TRACE_COUNT = 'X-Datadog-Trace-Count'.freeze
+            SERVICE_RATE_KEY = 'rate_by_service'.freeze
+
+            attr_reader \
+              :encoder
+
+            def initialize(path, encoder, options = {})
+              super(:post, path)
+              @encoder = encoder
+              @service_rates = options.fetch(:service_rates, false)
+            end
+
+            def service_rates?
+              @service_rates == true
+            end
+
+            def call(env, &block)
+              # Add trace count header
+              env.headers[HEADER_TRACE_COUNT] = env.request.parcel.count.to_s
+
+              # Encode body & type
+              env.headers[HEADER_CONTENT_TYPE] = encoder.content_type
+              env.body = env.request.parcel.encode_with(encoder)
+
+              # Query for response
+              http_response = super(env, &block)
+
+              # Process the response
+              response_options = {}.tap do |options|
+                # Parse service rates, if configured to do so.
+                if service_rates? && !http_response.payload.to_s.empty?
+                  body = JSON.parse(http_response.payload)
+                  if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
+                    options[:service_rates] = body[SERVICE_RATE_KEY]
+                  end
+                end
+              end
+
+              # Build and return a trace response
+              Traces::Response.new(http_response, response_options)
+            end
+          end
+        end
+
+        # Add traces behavior to transport components
+        HTTP::Client.send(:include, Traces::Client)
+        HTTP::API::Spec.send(:include, Traces::API::Spec)
+        HTTP::API::Instance.send(:include, Traces::API::Instance)
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/parcel.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Transport
+    # Data transfer object for generic data
+    module Parcel
+      attr_reader \
+        :data
+
+      def initialize(data)
+        @data = data
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/request.rb

@@ -0,0 +1,13 @@
+module Datadog
+  module Transport
+    # Defines request for transport operations
+    class Request
+      attr_reader \
+        :parcel
+
+      def initialize(parcel)
+        @parcel = parcel
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/response.rb

@@ -0,0 +1,49 @@
+module Datadog
+  module Transport
+    # Defines abstract response for transport operations
+    module Response
+      def payload
+        nil
+      end
+
+      def ok?
+        nil
+      end
+
+      def unsupported?
+        nil
+      end
+
+      def not_found?
+        nil
+      end
+
+      def client_error?
+        nil
+      end
+
+      def server_error?
+        nil
+      end
+
+      def internal_error?
+        nil
+      end
+    end
+
+    # A generic error response for internal errors
+    class InternalErrorResponse
+      include Response
+
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def internal_error?
+        true
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/statistics.rb

@@ -0,0 +1,72 @@
+require 'ddtrace/diagnostics/health'
+
+module Datadog
+  module Transport
+    # Tracks statistics for transports
+    module Statistics
+      def stats
+        @stats ||= Counts.new
+      end
+
+      def update_stats_from_response!(response)
+        if response.ok?
+          stats.success += 1
+          stats.consecutive_errors = 0
+        else
+          stats.client_error += 1 if response.client_error?
+          stats.server_error += 1 if response.server_error?
+          stats.internal_error += 1 if response.internal_error?
+          stats.consecutive_errors += 1
+        end
+
+        # Send health metrics
+        Diagnostics::Health.metrics.send_metrics(
+          metrics_for_response(response).values
+        )
+      end
+
+      def metrics_for_response(response)
+        {}.tap do |metrics|
+          metrics[:api_errors] = Metrics::Metric.new(:api_errors, nil, 1) if response.internal_error?
+          metrics[:api_responses] = Metrics::Metric.new(:api_responses, nil, 1) unless response.internal_error?
+        end
+      end
+
+      def update_stats_from_exception!(exception)
+        stats.internal_error += 1
+        stats.consecutive_errors += 1
+
+        # Send health metrics
+        Diagnostics::Health.metrics.send_metrics(
+          metrics_for_exception(exception).values
+        )
+      end
+
+      def metrics_for_exception(_exception)
+        { api_errors: Metrics::Metric.new(:api_errors, nil, 1) }
+      end
+
+      # Stat counts
+      class Counts
+        attr_accessor \
+          :success,
+          :client_error,
+          :server_error,
+          :internal_error,
+          :consecutive_errors
+
+        def initialize
+          reset!
+        end
+
+        def reset!
+          @success = 0
+          @client_error = 0
+          @server_error = 0
+          @internal_error = 0
+          @consecutive_errors = 0
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/transport/traces.rb

@@ -0,0 +1,33 @@
+require 'ddtrace/transport/parcel'
+require 'ddtrace/transport/request'
+
+module Datadog
+  module Transport
+    module Traces
+      # Data transfer object for trace data
+      class Parcel
+        include Transport::Parcel
+
+        def count
+          data.length
+        end
+
+        def encode_with(encoder)
+          encoder.encode_traces(data)
+        end
+      end
+
+      # Traces request
+      class Request < Transport::Request
+        def initialize(traces)
+          super(Parcel.new(traces))
+        end
+      end
+
+      # Traces response
+      module Response
+        attr_reader :service_rates
+      end
+    end
+  end
+end

data/lib/ddtrace/utils.rb

@@ -0,0 +1,65 @@
+require 'ddtrace/utils/database'
+
+module Datadog
+  # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
+  module Utils
+    STRING_PLACEHOLDER = ''.encode(::Encoding::UTF_8).freeze
+    # We use a custom random number generator because we want no interference
+    # with the default one. Using the default prng, we could break code that
+    # would rely on srand/rand sequences.
+
+    # Return a span id
+    def self.next_id
+      reset! if was_forked?
+
+      @rnd.rand(Datadog::Span::MAX_ID)
+    end
+
+    def self.reset!
+      @pid = Process.pid
+      @rnd = Random.new
+    end
+
+    def self.was_forked?
+      Process.pid != @pid
+    end
+
+    private_class_method :reset!, :was_forked?
+
+    reset!
+
+    def self.truncate(value, size, omission = '...'.freeze)
+      string = value.to_s
+
+      return string if string.size <= size
+
+      string = string.slice(0, size - 1)
+
+      if size < omission.size
+        string[0, size] = omission
+      else
+        string[size - omission.size, size] = omission
+      end
+
+      string
+    end
+
+    def self.utf8_encode(str, options = {})
+      str = str.to_s
+
+      if options[:binary]
+        # This option is useful for "gracefully" displaying binary data that
+        # often contains text such as marshalled objects
+        str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+      elsif str.encoding == ::Encoding::UTF_8
+        str
+      else
+        str.encode(::Encoding::UTF_8)
+      end
+    rescue => e
+      Tracer.log.debug("Error encoding string in UTF-8: #{e}")
+
+      options.fetch(:placeholder, STRING_PLACEHOLDER)
+    end
+  end
+end

data/lib/ddtrace/utils/database.rb

@@ -0,0 +1,25 @@
+module Datadog
+  module Utils
+    # Common database-related utility functions.
+    module Database
+      VENDOR_DEFAULT = 'defaultdb'.freeze
+      VENDOR_POSTGRES = 'postgres'.freeze
+      VENDOR_SQLITE = 'sqlite'.freeze
+
+      module_function
+
+      def normalize_vendor(vendor)
+        case vendor
+        when nil
+          VENDOR_DEFAULT
+        when 'postgresql'
+          VENDOR_POSTGRES
+        when 'sqlite3'
+          VENDOR_SQLITE
+        else
+          vendor
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/time.rb

@@ -0,0 +1,14 @@
+module Datadog
+  module Utils
+    # Common database-related utility functions.
+    module Time
+      PROCESS_TIME_SUPPORTED = Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.1.0')
+
+      module_function
+
+      def get_time
+        PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : ::Time.now.to_f
+      end
+    end
+  end
+end

data/lib/ddtrace/vendor/active_record/connection_specification.rb

@@ -0,0 +1,301 @@
+require 'uri'
+
+# NOTE: This code is copied directly from ActiveRecord.
+#       Its purpose is to resolve connection information.
+#       It exists here only because it doesn't exist in Rails 3.2.
+#       When support for Rails 3.2 is dropped, this can be removed.
+module Datadog
+  module Vendor
+    module ActiveRecord
+      # Copy/paste from:
+      # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_handling.rb
+      module ConnectionHandling
+        RAILS_ENV = -> { (Rails.env if defined?(Rails) && defined?(Rails.env)) || ENV["RAILS_ENV"].presence || ENV["RACK_ENV"].presence }
+      end
+
+      # Copy/paste from:
+      # https://github.com/rails/rails/blob/5-2-stable/activerecord/lib/active_record/connection_adapters/connection_specification.rb
+      module ConnectionAdapters
+        class ConnectionSpecification
+          attr_reader :name, :config, :adapter_method
+
+          def initialize(name, config, adapter_method)
+            @name, @config, @adapter_method = name, config, adapter_method
+          end
+
+          def initialize_dup(original)
+            @config = original.config.dup
+          end
+
+          def to_hash
+            @config.merge(name: @name)
+          end
+
+          # Expands a connection string into a hash.
+          class ConnectionUrlResolver # :nodoc:
+            # == Example
+            #
+            #   url = "postgresql://foo:bar@localhost:9000/foo_test?pool=5&timeout=3000"
+            #   ConnectionUrlResolver.new(url).to_hash
+            #   # => {
+            #     "adapter"  => "postgresql",
+            #     "host"     => "localhost",
+            #     "port"     => 9000,
+            #     "database" => "foo_test",
+            #     "username" => "foo",
+            #     "password" => "bar",
+            #     "pool"     => "5",
+            #     "timeout"  => "3000"
+            #   }
+            def initialize(url)
+              raise "Database URL cannot be empty" if url.blank?
+              @uri     = uri_parser.parse(url)
+              @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
+              @adapter = "postgresql" if @adapter == "postgres"
+
+              if @uri.opaque
+                @uri.opaque, @query = @uri.opaque.split("?", 2)
+              else
+                @query = @uri.query
+              end
+            end
+
+            # Converts the given URL to a full connection hash.
+            def to_hash
+              config = raw_config.reject { |_, value| value.blank? }
+              config.map { |key, value| config[key] = uri_parser.unescape(value) if value.is_a? String }
+              config
+            end
+
+            private
+
+              def uri
+                @uri
+              end
+
+              def uri_parser
+                @uri_parser ||= URI::Parser.new
+              end
+
+              # Converts the query parameters of the URI into a hash.
+              #
+              #   "localhost?pool=5&reaping_frequency=2"
+              #   # => { "pool" => "5", "reaping_frequency" => "2" }
+              #
+              # returns empty hash if no query present.
+              #
+              #   "localhost"
+              #   # => {}
+              def query_hash
+                Hash[(@query || "").split("&").map { |pair| pair.split("=") }]
+              end
+
+              def raw_config
+                if uri.opaque
+                  query_hash.merge(
+                    "adapter"  => @adapter,
+                    "database" => uri.opaque)
+                else
+                  query_hash.merge(
+                    "adapter"  => @adapter,
+                    "username" => uri.user,
+                    "password" => uri.password,
+                    "port"     => uri.port,
+                    "database" => database_from_path,
+                    "host"     => uri.hostname)
+                end
+              end
+
+              # Returns name of the database.
+              def database_from_path
+                if @adapter == "sqlite3"
+                  # 'sqlite3:/foo' is absolute, because that makes sense. The
+                  # corresponding relative version, 'sqlite3:foo', is handled
+                  # elsewhere, as an "opaque".
+
+                  uri.path
+                else
+                  # Only SQLite uses a filename as the "database" name; for
+                  # anything else, a leading slash would be silly.
+
+                  uri.path.sub(%r{^/}, "")
+                end
+              end
+          end
+
+          ##
+          # Builds a ConnectionSpecification from user input.
+          class Resolver # :nodoc:
+            attr_reader :configurations
+
+            # Accepts a hash two layers deep, keys on the first layer represent
+            # environments such as "production". Keys must be strings.
+            def initialize(configurations)
+              @configurations = configurations
+            end
+
+            # Returns a hash with database connection information.
+            #
+            # == Examples
+            #
+            # Full hash Configuration.
+            #
+            #   configurations = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+            #   Resolver.new(configurations).resolve(:production)
+            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3"}
+            #
+            # Initialized with URL configuration strings.
+            #
+            #   configurations = { "production" => "postgresql://localhost/foo" }
+            #   Resolver.new(configurations).resolve(:production)
+            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+            #
+            def resolve(config)
+              if config
+                resolve_connection config
+              elsif env = ConnectionHandling::RAILS_ENV.call
+                resolve_symbol_connection env.to_sym
+              else
+                raise AdapterNotSpecified
+              end
+            end
+
+            # Expands each key in @configurations hash into fully resolved hash
+            def resolve_all
+              config = configurations.dup
+
+              if env = ConnectionHandling::DEFAULT_ENV.call
+                env_config = config[env] if config[env].is_a?(Hash) && !(config[env].key?("adapter") || config[env].key?("url"))
+              end
+
+              config.reject! { |k, v| v.is_a?(Hash) && !(v.key?("adapter") || v.key?("url")) }
+              config.merge! env_config if env_config
+
+              config.each do |key, value|
+                config[key] = resolve(value) if value
+              end
+
+              config
+            end
+
+            # Returns an instance of ConnectionSpecification for a given adapter.
+            # Accepts a hash one layer deep that contains all connection information.
+            #
+            # == Example
+            #
+            #   config = { "production" => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" } }
+            #   spec = Resolver.new(config).spec(:production)
+            #   spec.adapter_method
+            #   # => "sqlite3_connection"
+            #   spec.config
+            #   # => { "host" => "localhost", "database" => "foo", "adapter" => "sqlite3" }
+            #
+            def spec(config)
+              spec = resolve(config).symbolize_keys
+
+              raise(AdapterNotSpecified, "database configuration does not specify adapter") unless spec.key?(:adapter)
+
+              # Require the adapter itself and give useful feedback about
+              #   1. Missing adapter gems and
+              #   2. Adapter gems' missing dependencies.
+              path_to_adapter = "active_record/connection_adapters/#{spec[:adapter]}_adapter"
+              begin
+                require path_to_adapter
+              rescue LoadError => e
+                # We couldn't require the adapter itself. Raise an exception that
+                # points out config typos and missing gems.
+                if e.path == path_to_adapter
+                  # We can assume that a non-builtin adapter was specified, so it's
+                  # either misspelled or missing from Gemfile.
+                  raise e.class, "Could not load the '#{spec[:adapter]}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
+
+                # Bubbled up from the adapter require. Prefix the exception message
+                # with some guidance about how to address it and reraise.
+                else
+                  raise e.class, "Error loading the '#{spec[:adapter]}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+                end
+              end
+
+              adapter_method = "#{spec[:adapter]}_connection"
+
+              unless ::ActiveRecord::Base.respond_to?(adapter_method)
+                raise AdapterNotFound, "database configuration specifies nonexistent #{spec.config[:adapter]} adapter"
+              end
+
+              ConnectionSpecification.new(spec.delete(:name) || "primary", spec, adapter_method)
+            end
+
+            private
+
+              # Returns fully resolved connection, accepts hash, string or symbol.
+              # Always returns a hash.
+              #
+              # == Examples
+              #
+              # Symbol representing current environment.
+              #
+              #   Resolver.new("production" => {}).resolve_connection(:production)
+              #   # => {}
+              #
+              # One layer deep hash of connection values.
+              #
+              #   Resolver.new({}).resolve_connection("adapter" => "sqlite3")
+              #   # => { "adapter" => "sqlite3" }
+              #
+              # Connection URL.
+              #
+              #   Resolver.new({}).resolve_connection("postgresql://localhost/foo")
+              #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+              #
+              def resolve_connection(spec)
+                case spec
+                when Symbol
+                  resolve_symbol_connection spec
+                when String
+                  resolve_url_connection spec
+                when Hash
+                  resolve_hash_connection spec
+                end
+              end
+
+              # Takes the environment such as +:production+ or +:development+.
+              # This requires that the @configurations was initialized with a key that
+              # matches.
+              #
+              #   Resolver.new("production" => {}).resolve_symbol_connection(:production)
+              #   # => {}
+              #
+              def resolve_symbol_connection(spec)
+                if config = configurations[spec.to_s]
+                  resolve_connection(config).merge("name" => spec.to_s)
+                else
+                  raise(AdapterNotSpecified, "'#{spec}' database is not configured. Available: #{configurations.keys.inspect}")
+                end
+              end
+
+              # Accepts a hash. Expands the "url" key that contains a
+              # URL database connection to a full connection
+              # hash and merges with the rest of the hash.
+              # Connection details inside of the "url" key win any merge conflicts
+              def resolve_hash_connection(spec)
+                if spec["url"] && spec["url"] !~ /^jdbc:/
+                  connection_hash = resolve_url_connection(spec.delete("url"))
+                  spec.merge!(connection_hash)
+                end
+                spec
+              end
+
+              # Takes a connection URL.
+              #
+              #   Resolver.new({}).resolve_url_connection("postgresql://localhost/foo")
+              #   # => { "host" => "localhost", "database" => "foo", "adapter" => "postgresql" }
+              #
+              def resolve_url_connection(url)
+                ConnectionUrlResolver.new(url).to_hash
+              end
+          end
+        end
+      end
+    end
+  end
+end