ddtrace 0.8.2 → 0.9.0

data/lib/ddtrace/contrib/aws/parsed_context.rb

@@ -0,0 +1,56 @@
+module Datadog
+  module Contrib
+    module Aws
+      # A wrapper around Seahorse::Client::RequestContext
+      class ParsedContext
+        def initialize(context)
+          @context = context
+        end
+
+        def safely(attr, fallback = nil)
+          public_send(attr) rescue fallback
+        end
+
+        def resource
+          "#{service}.#{operation}"
+        end
+
+        def operation
+          context.operation_name
+        end
+
+        def status_code
+          context.http_response.status_code
+        end
+
+        def http_method
+          context.http_request.http_method
+        end
+
+        def region
+          context.client.config.region
+        end
+
+        def retry_attempts
+          context.retries
+        end
+
+        def path
+          context.http_request.endpoint.path
+        end
+
+        def host
+          context.http_request.endpoint.host
+        end
+
+        private
+
+        attr_reader :context
+
+        def service
+          context.client.class.to_s.split('::')[1].downcase
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/aws/patcher.rb

@@ -0,0 +1,56 @@
+module Datadog
+  module Contrib
+    module Aws
+      SERVICE = 'aws'.freeze
+      AGENT = 'aws-sdk-ruby'.freeze
+      RESOURCE = 'aws.command'.freeze
+
+      # Responsible for hooking the instrumentation into aws-sdk
+      module Patcher
+        @patched = false
+
+        class << self
+          def patch
+            return @patched if patched? || !defined?(Seahorse::Client::Base)
+
+            require 'ddtrace/ext/app_types'
+            require 'ddtrace/contrib/aws/parsed_context'
+            require 'ddtrace/contrib/aws/instrumentation'
+            require 'ddtrace/contrib/aws/services'
+
+            add_pin
+            add_plugin(Seahorse::Client::Base, *loaded_constants)
+
+            @patched = true
+          rescue => e
+            Datadog::Tracer.log.error("Unable to apply AWS integration: #{e}")
+            @patched
+          end
+
+          def patched?
+            @patched
+          end
+
+          private
+
+          def add_pin
+            Pin.new(SERVICE, app_type: Ext::AppTypes::WEB).tap do |pin|
+              pin.onto(::Aws)
+            end
+          end
+
+          def add_plugin(*targets)
+            targets.each { |klass| klass.add_plugin(Instrumentation) }
+          end
+
+          def loaded_constants
+            SERVICES.each_with_object([]) do |service, constants|
+              next if ::Aws.autoload?(service)
+              constants << ::Aws.const_get(service).const_get(:Client) rescue next
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/aws/services.rb

@@ -0,0 +1,115 @@
+module Datadog
+  module Contrib
+    # rubocop:disable Metrics/ModuleLength:
+    module Aws
+      SERVICES = %w[
+        ACM
+        APIGateway
+        AppStream
+        ApplicationAutoScaling
+        ApplicationDiscoveryService
+        Athena
+        AutoScaling
+        Batch
+        Budgets
+        CloudDirectory
+        CloudFormation
+        CloudFront
+        CloudHSM
+        CloudHSMV2
+        CloudSearch
+        CloudSearchDomain
+        CloudTrail
+        CloudWatch
+        CloudWatchEvents
+        CloudWatchLogs
+        CodeBuild
+        CodeCommit
+        CodeDeploy
+        CodePipeline
+        CodeStar
+        CognitoIdentity
+        CognitoIdentityProvider
+        CognitoSync
+        ConfigService
+        CostandUsageReportService
+        DAX
+        DataPipeline
+        DatabaseMigrationService
+        DeviceFarm
+        DirectConnect
+        DirectoryService
+        DynamoDB
+        DynamoDBStreams
+        EC2
+        ECR
+        ECS
+        EFS
+        EMR
+        ElastiCache
+        ElasticBeanstalk
+        ElasticLoadBalancing
+        ElasticLoadBalancingV2
+        ElasticTranscoder
+        ElasticsearchService
+        Firehose
+        GameLift
+        Glacier
+        Glue
+        Greengrass
+        Health
+        IAM
+        ImportExport
+        Inspector
+        IoT
+        IoTDataPlane
+        KMS
+        Kinesis
+        KinesisAnalytics
+        Lambda
+        LambdaPreview
+        Lex
+        LexModelBuildingService
+        Lightsail
+        MTurk
+        MachineLearning
+        MarketplaceCommerceAnalytics
+        MarketplaceEntitlementService
+        MarketplaceMetering
+        MigrationHub
+        Mobile
+        OpsWorks
+        OpsWorksCM
+        Organizations
+        Pinpoint
+        Polly
+        RDS
+        Redshift
+        Rekognition
+        ResourceGroupsTaggingAPI
+        Route53
+        Route53Domains
+        S3
+        SES
+        SMS
+        SNS
+        SQS
+        SSM
+        STS
+        SWF
+        ServiceCatalog
+        Shield
+        SimpleDB
+        Snowball
+        States
+        StorageGateway
+        Support
+        WAF
+        WAFRegional
+        WorkDocs
+        WorkSpaces
+        XRay
+      ].freeze
+    end
+  end
+end

data/lib/ddtrace/contrib/dalli/instrumentation.rb

@@ -0,0 +1,35 @@
+require_relative 'quantize'
+require 'ddtrace/ext/net'
+
+module Datadog
+  module Contrib
+    module Dalli
+      # Instruments every interaction with the memcached server
+      module Instrumentation
+        module_function
+
+        def patch!
+          ::Dalli::Server.class_eval do
+            alias_method :__request, :request
+
+            def request(op, *args)
+              pin = Datadog::Pin.get_from(::Dalli)
+
+              pin.tracer.trace(Datadog::Contrib::Dalli::NAME) do |span|
+                span.resource = op.to_s.upcase
+                span.service = pin.service
+                span.span_type = pin.app_type
+                span.set_tag(Datadog::Ext::NET::TARGET_HOST, hostname)
+                span.set_tag(Datadog::Ext::NET::TARGET_PORT, port)
+                cmd = Datadog::Contrib::Dalli::Quantize.format_command(op, args)
+                span.set_tag(Datadog::Contrib::Dalli::CMD_TAG, cmd)
+
+                __request(op, *args)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/dalli/patcher.rb

@@ -0,0 +1,50 @@
+module Datadog
+  module Contrib
+    module Dalli
+      COMPATIBLE_WITH = Gem::Version.new('2.0.0')
+      SERVICE = 'memcached'.freeze
+      NAME = 'memcached.command'.freeze
+      CMD_TAG = 'memcached.command'.freeze
+
+      # Responsible for hooking the instrumentation into `dalli`
+      module Patcher
+        @patched = false
+
+        class << self
+          def patch
+            return @patched if patched? || !compatible?
+
+            require 'ddtrace/ext/app_types'
+            require_relative 'instrumentation'
+
+            add_pin!
+            Instrumentation.patch!
+
+            @patched = true
+          rescue => e
+            Tracer.log.error("Unable to apply Dalli integration: #{e}")
+            @patched
+          end
+
+          def patched?
+            @patched
+          end
+
+          private
+
+          def compatible?
+            return unless defined?(::Dalli::VERSION)
+
+            Gem::Version.new(::Dalli::VERSION) > COMPATIBLE_WITH
+          end
+
+          def add_pin!
+            Pin.new(SERVICE, app_type: Ext::AppTypes::DB).tap do |pin|
+              pin.onto(::Dalli)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/dalli/quantize.rb

@@ -0,0 +1,17 @@
+module Datadog
+  module Contrib
+    module Dalli
+      # Quantize contains dalli-specic quantization tools.
+      module Quantize
+        MAX_CMD_LENGTH = 100
+
+        module_function
+
+        def format_command(operation, args)
+          command = [operation, *args].join(' ').strip
+          Utils.truncate(command, MAX_CMD_LENGTH)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/faraday/middleware.rb

@@ -0,0 +1,75 @@
+require 'faraday'
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/distributed'
+
+module Datadog
+  module Contrib
+    module Faraday
+      # Middleware implements a faraday-middleware for ddtrace instrumentation
+      class Middleware < ::Faraday::Middleware
+        DEFAULT_ERROR_HANDLER = lambda do |env|
+          Ext::HTTP::ERROR_RANGE.cover?(env[:status])
+        end
+
+        DEFAULT_OPTIONS = {
+          distributed_tracing: false,
+          split_by_domain: false,
+          error_handler: DEFAULT_ERROR_HANDLER
+        }.freeze
+
+        def initialize(app, options = {})
+          super(app)
+          @options = DEFAULT_OPTIONS.merge(options)
+        end
+
+        def call(env)
+          dd_pin.tracer.trace(SERVICE) do |span|
+            annotate!(span, env)
+            propagate!(span, env) if options[:distributed_tracing]
+            app.call(env).on_complete { |resp| handle_response(span, resp) }
+          end
+        end
+
+        private
+
+        attr_reader :app, :options
+
+        def annotate!(span, env)
+          span.resource = env[:method].to_s.upcase
+          span.service = service_name(env)
+          span.span_type = Ext::HTTP::TYPE
+          span.set_tag(Ext::HTTP::URL, env[:url].path)
+          span.set_tag(Ext::HTTP::METHOD, env[:method].to_s.upcase)
+          span.set_tag(Ext::NET::TARGET_HOST, env[:url].host)
+          span.set_tag(Ext::NET::TARGET_PORT, env[:url].port)
+        end
+
+        def handle_response(span, env)
+          if options.fetch(:error_handler).call(env)
+            span.set_error(["Error #{env[:status]}", env[:body]])
+          end
+
+          span.set_tag(Ext::HTTP::STATUS_CODE, env[:status])
+        end
+
+        def propagate!(span, env)
+          env[:request_headers].merge!(
+            Ext::DistributedTracing::HTTP_HEADER_TRACE_ID => span.trace_id.to_s,
+            Ext::DistributedTracing::HTTP_HEADER_PARENT_ID => span.span_id.to_s
+          )
+        end
+
+        def dd_pin
+          Pin.get_from(::Faraday)
+        end
+
+        def service_name(env)
+          return env[:url].host if options[:split_by_domain]
+
+          dd_pin.service
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/faraday/patcher.rb

@@ -0,0 +1,52 @@
+module Datadog
+  module Contrib
+    module Faraday
+      COMPATIBLE_UNTIL = Gem::Version.new('1.0.0')
+      SERVICE = 'faraday-request'.freeze
+
+      # Responsible for hooking the instrumentation into faraday
+      module Patcher
+        @patched = false
+
+        class << self
+          def patch
+            return @patched if patched? || !compatible?
+
+            require 'ddtrace/ext/app_types'
+            require 'ddtrace/contrib/faraday/middleware'
+
+            add_pin
+            add_middleware
+
+            @patched = true
+          rescue => e
+            Tracer.log.error("Unable to apply Faraday integration: #{e}")
+            @patched
+          end
+
+          def patched?
+            @patched
+          end
+
+          private
+
+          def compatible?
+            return unless defined?(::Faraday::VERSION)
+
+            Gem::Version.new(::Faraday::VERSION) < COMPATIBLE_UNTIL
+          end
+
+          def add_pin
+            Pin.new(SERVICE, app_type: Ext::AppTypes::WEB).tap do |pin|
+              pin.onto(::Faraday)
+            end
+          end
+
+          def add_middleware
+            ::Faraday::Middleware.register_middleware(ddtrace: Middleware)
+          end
+        end
+      end
+    end
+  end
+end