ddtrace 0.49.0 → 1.12.1

data/lib/datadog/tracing/contrib/aws/instrumentation.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative '../span_attribute_schema'
+
+module Datadog
+  module Tracing
+    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)
+            Tracing.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 = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+            span.name = Ext::SPAN_COMMAND
+            span.resource = context.safely(:resource)
+            aws_service = span.resource.split('.')[0]
+            span.set_tag(Ext::TAG_AWS_SERVICE, aws_service)
+            params = context.safely(:params)
+            if (handler = Datadog::Tracing::Contrib::Aws::SERVICE_HANDLERS[aws_service])
+              handler.add_tags(span, params)
+            end
+
+            span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+            span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
+
+            # Tag as an external peer service
+            if Contrib::SpanAttributeSchema.default_span_attribute_schema?
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+            end
+
+            span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, context.safely(:host))
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+            Contrib::Analytics.set_measured(span)
+
+            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_AWS_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(Tracing::Metadata::Ext::HTTP::TAG_METHOD, context.safely(:http_method))
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, context.safely(:status_code))
+          end
+
+          def configuration
+            Datadog.configuration.tracing[:aws]
+          end
+        end
+
+        # Removes API request instrumentation from S3 Presign URL creation.
+        #
+        # This is necessary because the S3 SDK invokes the same handler
+        # stack for presigning as it does for sending a real requests.
+        # But presigning does not perform a network request.
+        # There's not information available for our Handler plugin to differentiate
+        # these two types of requests.
+        #
+        # DEV: Since aws-sdk-s3 1.94.1, we only need to check if
+        # `context[:presigned_url] == true` in Datadog::Tracing::Contrib::Aws::Handler#call
+        # and skip the request if that condition is true. Since there's
+        # no strong reason for us not to support older versions of `aws-sdk-s3`,
+        # this {S3Presigner} monkey-patching is still required.
+        module S3Presigner
+          # Exclude our Handler from the current request's handler stack.
+          #
+          # This is the same approach that the AWS SDK takes to prevent
+          # some of its plugins form interfering with the presigning process:
+          # https://github.com/aws/aws-sdk-ruby/blob/a82c8981c95a8296ffb6269c3c06a4f551d87f7d/gems/aws-sdk-s3/lib/aws-sdk-s3/presigner.rb#L194-L196
+          def sign_but_dont_send(*args, &block)
+            if (request = args[0]).is_a?(::Seahorse::Client::Request)
+              request.handlers.remove(Handler)
+            end
+
+            super(*args, &block)
+          end
+
+          ruby2_keywords :sign_but_dont_send if respond_to?(:ruby2_keywords, true)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/integration.rb

@@ -0,0 +1,45 @@
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        # Description of AWS integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('2.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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 new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/parsed_context.rb

@@ -0,0 +1,62 @@
+module Datadog
+  module Tracing
+    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 params
+            context.params
+          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
+end

data/lib/datadog/tracing/contrib/aws/patcher.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    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_relative 'parsed_context'
+            require_relative 'instrumentation'
+            require_relative 'services'
+
+            add_plugin(Seahorse::Client::Base, *loaded_constants)
+
+            # Special handling for S3 URL Presigning.
+            # @see Datadog::Tracing::Contrib::Aws::S3Presigner
+            ::Aws::S3::Presigner.prepend(S3Presigner) if defined?(::Aws::S3::Presigner)
+          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.tracing[:aws].get_option(option)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # Base class for all AWS service-specific tag handlers.
+          class Base
+            def add_tags(span, params); end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/dynamodb.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # DynamoDB tag handlers.
+          class DynamoDB < Base
+            def add_tags(span, params)
+              table_name = params[:table_name]
+              span.set_tag(Aws::Ext::TAG_TABLE_NAME, table_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/eventbridge.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # EventBridge tag handlers.
+          class EventBridge < Base
+            def add_tags(span, params)
+              rule_name = params[:name] || params[:rule]
+              span.set_tag(Aws::Ext::TAG_RULE_NAME, rule_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/kinesis.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # Kinesis tag handlers.
+          class Kinesis < Base
+            def add_tags(span, params)
+              stream_arn = params[:stream_arn]
+              stream_name = params[:stream_name]
+
+              if stream_arn
+                # example stream_arn: arn:aws:kinesis:us-east-1:123456789012:stream/my-stream
+                parts = stream_arn.split(':')
+                stream_name = parts[-1].split('/')[-1]
+                aws_account = parts[-2]
+                span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, aws_account)
+              end
+
+              span.set_tag(Aws::Ext::TAG_STREAM_NAME, stream_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/s3.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # S3 tag handlers.
+          class S3 < Base
+            def add_tags(span, params)
+              bucket_name = params[:bucket]
+              span.set_tag(Aws::Ext::TAG_BUCKET_NAME, bucket_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/sns.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # SNS tag handlers.
+          class SNS < Base
+            def add_tags(span, params)
+              topic_arn = params[:topic_arn]
+              topic_name = params[:name]
+              if topic_arn
+                # example topic_arn: arn:aws:sns:us-west-2:123456789012:my-topic-name
+                parts = topic_arn.split(':')
+                topic_name = parts[-1]
+                aws_account = parts[-2]
+                span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, aws_account)
+              end
+              span.set_tag(Aws::Ext::TAG_TOPIC_NAME, topic_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/sqs.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # SQS tag handlers.
+          class SQS < Base
+            def add_tags(span, params)
+              queue_url = params[:queue_url]
+              queue_name = params[:queue_name]
+              if queue_url
+                _, _, _, aws_account, queue_name = queue_url.split('/')
+                span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, aws_account)
+              end
+              span.set_tag(Aws::Ext::TAG_QUEUE_NAME, queue_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/service/states.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative './base'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Aws
+        module Service
+          # States tag handlers.
+          class States < Base
+            def add_tags(span, params)
+              state_machine_name = params[:name]
+              state_machine_arn = params[:state_machine_arn]
+              execution_arn = params[:execution_arn]
+              state_machine_account_id = ''
+
+              if execution_arn
+                # 'arn:aws:states:us-east-1:123456789012:execution:example-state-machine:example-execution'
+                parts = execution_arn.split(':')
+                state_machine_name = parts[-2]
+                state_machine_account_id = parts[4]
+              end
+
+              if state_machine_arn
+                # example statemachinearn: arn:aws:states:us-east-1:123456789012:stateMachine:MyStateMachine
+                parts = state_machine_arn.split(':')
+                state_machine_name ||= parts[-1]
+                state_machine_account_id = parts[-3]
+              end
+              span.set_tag(Aws::Ext::TAG_AWS_ACCOUNT, state_machine_account_id)
+              span.set_tag(Aws::Ext::TAG_STATE_MACHINE_NAME, state_machine_name)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/aws/services.rb

@@ -0,0 +1,137 @@
+require_relative './service/sqs'
+require_relative './service/sns'
+require_relative './service/dynamodb'
+require_relative './service/kinesis'
+require_relative './service/eventbridge'
+require_relative './service/states'
+require_relative './service/s3'
+
+module Datadog
+  module Tracing
+    module Contrib
+      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
+          EventBridge
+          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
+          Schemas
+          Shield
+          SimpleDB
+          Snowball
+          States
+          StorageGateway
+          Support
+          Textract
+          WAF
+          WAFRegional
+          WorkDocs
+          WorkSpaces
+          XRay
+        ].freeze
+
+        SERVICE_HANDLERS = {
+          'sqs' => Service::SQS.new,
+          'sns' => Service::SNS.new,
+          'dynamodb' => Service::DynamoDB.new,
+          'kinesis' => Service::Kinesis.new,
+          'eventbridge' => Service::EventBridge.new,
+          'states' => Service::States.new,
+          's3' => Service::S3.new
+        }.freeze
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/concurrent_ruby/configuration/settings.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        module Configuration
+          # Custom settings for the ConcurrentRuby integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+          end
+        end
+      end
+    end
+  end
+end