ddtrace 0.38.0

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

@@ -0,0 +1,23 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_support/cache/patcher'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      # Patcher enables patching of 'active_support' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          Cache::Patcher.patch
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/analytics.rb

@@ -0,0 +1,24 @@
+require 'ddtrace/analytics'
+
+module Datadog
+  module Contrib
+    # Defines analytics behavior for integrations
+    module Analytics
+      module_function
+
+      # Checks whether analytics should be enabled.
+      # `flag` is a truthy/falsey value that represents a setting on the integration.
+      def enabled?(flag = nil)
+        (Datadog.configuration.analytics.enabled && flag != false) || flag == true
+      end
+
+      def set_sample_rate(span, sample_rate)
+        Datadog::Analytics.set_sample_rate(span, sample_rate)
+      end
+
+      def set_measured(span, value = true)
+        Datadog::Analytics.set_measured(span, value)
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/aws/configuration/settings.rb

@@ -0,0 +1,25 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/aws/ext'
+
+module Datadog
+  module Contrib
+    module Aws
+      module Configuration
+        # Custom settings for the AWS integration
+        class Settings < Contrib::Configuration::Settings
+          option :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 1.0) }
+            o.lazy
+          end
+
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Datadog
+  module Contrib
+    module Aws
+      # AWS integration constants
+      module Ext
+        APP = 'aws'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_AWS_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_AWS_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'aws'.freeze
+        SPAN_COMMAND = 'aws.command'.freeze
+        TAG_AGENT = 'aws.agent'.freeze
+        TAG_DEFAULT_AGENT = 'aws-sdk-ruby'.freeze
+        TAG_HOST = 'host'.freeze
+        TAG_OPERATION = 'aws.operation'.freeze
+        TAG_PATH = 'path'.freeze
+        TAG_REGION = 'aws.region'.freeze
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/aws/ext'
+
+module Datadog
+  module Contrib
+    module Aws
+      # A Seahorse::Client::Plugin that enables instrumentation for all AWS services
+      class Instrumentation < Seahorse::Client::Plugin
+        def add_handlers(handlers, _)
+          handlers.add(Handler, step: :validate)
+        end
+      end
+
+      # Generates Spans for all interactions with AWS
+      class Handler < Seahorse::Client::Handler
+        def call(context)
+          tracer.trace(Ext::SPAN_COMMAND) do |span|
+            @handler.call(context).tap do
+              annotate!(span, ParsedContext.new(context))
+            end
+          end
+        end
+
+        private
+
+        def annotate!(span, context)
+          span.service = configuration[:service_name]
+          span.span_type = Datadog::Ext::AppTypes::WEB
+          span.name = Ext::SPAN_COMMAND
+          span.resource = context.safely(:resource)
+
+          # Set analytics sample rate
+          if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+          end
+
+          span.set_tag(Ext::TAG_AGENT, Ext::TAG_DEFAULT_AGENT)
+          span.set_tag(Ext::TAG_OPERATION, context.safely(:operation))
+          span.set_tag(Ext::TAG_REGION, context.safely(:region))
+          span.set_tag(Ext::TAG_PATH, context.safely(:path))
+          span.set_tag(Ext::TAG_HOST, context.safely(:host))
+          span.set_tag(Datadog::Ext::HTTP::METHOD, context.safely(:http_method))
+          span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, context.safely(:status_code))
+        end
+
+        def tracer
+          configuration[:tracer]
+        end
+
+        def configuration
+          Datadog.configuration[:aws]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/aws/configuration/settings'
+require 'ddtrace/contrib/aws/patcher'
+
+module Datadog
+  module Contrib
+    module Aws
+      # Description of AWS integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('2.0')
+
+        register_as :aws, auto_patch: true
+
+        def self.version
+          if Gem.loaded_specs['aws-sdk']
+            Gem.loaded_specs['aws-sdk'].version
+          elsif Gem.loaded_specs['aws-sdk-core']
+            Gem.loaded_specs['aws-sdk-core'].version
+          end
+        end
+
+        def self.loaded?
+          !defined?(::Seahorse::Client::Base).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

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,49 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/aws/ext'
+
+module Datadog
+  module Contrib
+    module Aws
+      # Patcher enables patching of 'aws' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          require 'ddtrace/contrib/aws/parsed_context'
+          require 'ddtrace/contrib/aws/instrumentation'
+          require 'ddtrace/contrib/aws/services'
+
+          add_plugin(Seahorse::Client::Base, *loaded_constants)
+        end
+
+        def add_plugin(*targets)
+          targets.each { |klass| klass.add_plugin(Instrumentation) }
+        end
+
+        def loaded_constants
+          # Cross-check services against loaded AWS constants
+          # Module#const_get can return a constant from ancestors when there's a miss.
+          # If this conincidentally matches another constant, it will attempt to patch
+          # the wrong constant, resulting in patch failure.
+          available_services = ::Aws.constants & SERVICES.map(&:to_sym)
+
+          available_services.each_with_object([]) do |service, constants|
+            next if ::Aws.autoload?(service)
+            constants << ::Aws.const_get(service, false).const_get(:Client, false) rescue next
+          end
+        end
+
+        def get_option(option)
+          Datadog.configuration[:aws].get_option(option)
+        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/concurrent_ruby/configuration/settings.rb

@@ -0,0 +1,15 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/concurrent_ruby/ext'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      module Configuration
+        # Custom settings for the ConcurrentRuby integration
+        class Settings < Contrib::Configuration::Settings
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/concurrent_ruby/context_composite_executor_service.rb

@@ -0,0 +1,41 @@
+require 'concurrent/executor/executor_service'
+
+module Datadog
+  module Contrib
+    module ConcurrentRuby
+      # wraps existing executor to carry over trace context
+      class ContextCompositeExecutorService
+        extend Forwardable
+        include Concurrent::ExecutorService
+
+        attr_accessor :composited_executor
+
+        def initialize(composited_executor)
+          @composited_executor = composited_executor
+        end
+
+        # post method runs the task within composited executor - in a different thread
+        def post(*args, &task)
+          parent_context = datadog_configuration.tracer.provider.context
+
+          @composited_executor.post(*args) do
+            begin
+              original_context = datadog_configuration.tracer.provider.context
+              datadog_configuration.tracer.provider.context = parent_context
+              yield
+            ensure
+              # Restore context in case the current thread gets reused
+              datadog_configuration.tracer.provider.context = original_context
+            end
+          end
+        end
+
+        def datadog_configuration
+          Datadog.configuration[:concurrent_ruby]
+        end
+
+        delegate [:can_overflow?, :serialized?] => :composited_executor
+      end
+    end
+  end
+end