opentelemetry-instrumentation-aws_sdk 0.5.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 877637b5387d476ece45e8537ccc2eed0dd52600c414cb2f96e0391a0ba06560
-  data.tar.gz: a643b9573b8dedaa45acc014970c4ecc85ba74f21ccd4fc240ed4c9165e4b7b7
+  metadata.gz: fc28b8e181dc59950237cb56fbde713e2083003bab88acd345bd90dba7b5eb1a
+  data.tar.gz: a479a21f7d6c14d691df13d7683bf5a680045185520205018d70a9736b306a2a
 SHA512:
-  metadata.gz: dec9fd1339e6ed63091a32e9c695927bef9e4c7c7b1d65fc2c1cacc56f5a3ae4d2739d1317878bbe98b4b95a882f90c1a3540d253ad9d5663581bca028b3d117
-  data.tar.gz: adc5712d47bdf9d7aad92fe6756f1c515994b1160d4cdbbe13b60bd7fd441a18c7be6d050be5681378f777a4d5f6d8afaf2d4c19d966d87c8546dfa610dfc730
+  metadata.gz: 86d3e8d2c0a94cd739f5abdeae3c762573d6e175b0fc4ffd682fc1811ce1da7fc2d4fd73ce0131573531b9f3643d9ef5b3bf775869aa9445012d43295af2c02c
+  data.tar.gz: 1b1d40e77d958f1869163cf01f1d6ddf6bb8713170747cf6d754fc225d6a9715efe6454a3b5f4fb7e9d5d0025d22ca745c0dccf46385718509f97a604fd3c33f

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Release History: opentelemetry-instrumentation-aws_sdk
 
+### v0.7.0 / 2024-10-08
+
+* ADDED: Integration with V3 telemetry provider
+
+### v0.6.0 / 2024-09-19
+
+* ADDED: All AWS services emit traces
+
 ### v0.5.4 / 2024-07-23
 
 * DOCS: Add cspell to CI

data/README.md

@@ -6,7 +6,7 @@ The OpenTelemetry `aws-sdk` gem is a community maintained instrumentation for [a
 
 Install the gem using:
 
-```
+```console
 gem install opentelemetry-instrumentation-aws_sdk
 ```
 
@@ -32,6 +32,30 @@ OpenTelemetry::SDK.configure do |c|
   c.use_all
 end
 ```
+### Configuration options
+This instrumentation offers the following configuration options: 
+* `:inject_messaging_context` (default: `false`): When set to `true`, adds context key/value 
+ to Message Attributes for SQS/SNS messages.
+* `suppress_internal_instrumentation` (default: `false`): When set to `true`, any spans with 
+ span kind of `internal` are suppressed from traces.
+
+## Integration with SDK V3's Telemetry support
+AWS SDK for Ruby V3 added support for Observability which includes a new configuration, 
+`telemetry_provider` and an OpenTelemetry-based telemetry provider. Only applies to
+AWS service gems released after 2024-09-03. 
+
+Using later versions of these gems will give more details on the internal spans. 
+See below for example usage:
+```ruby
+# configures the OpenTelemetry SDK with instrumentation defaults
+OpenTelemetry::SDK.configure do |c|
+  c.use 'OpenTelemetry::Instrumentation::AwsSdk'
+end
+
+# create open-telemetry provider and pass to client config
+otel_provider = Aws::Telemetry::OTelProvider.new
+client = Aws::S3::Client.new(telemetry_provider: otel_provider)
+```
 
 ## Example
 
@@ -49,7 +73,7 @@ This will run SNS publish command, printing OpenTelemetry traces to the console
 
 The `opentelemetry-instrumentation-aws_sdk` gem source is [on github][repo-github], along with related gems including `opentelemetry-api` and `opentelemetry-sdk`.
 
-The OpenTelemetry Ruby gems are maintained by the OpenTelemetry-Ruby special interest group (SIG). You can get involved by joining us in [GitHub Discussions][discussions-url] or attending our weekly meeting. See the [meeting calendar][community-meetings] for dates and times. For more information on this and other language SIGs, see the OpenTelemetry [community page][ruby-sig].
+The OpenTelemetry Ruby gems are maintained by the OpenTelemetry Ruby special interest group (SIG). You can get involved by joining us on our [GitHub Discussions][discussions-url], [Slack Channel][slack-channel] or attending our weekly meeting. See the [meeting calendar][community-meetings] for dates and times. For more information on this and other language SIGs, see the OpenTelemetry [community page][ruby-sig].
 
 ## License
 
@@ -61,4 +85,5 @@ Apache 2.0 license. See [LICENSE][license-github] for more information.
 [license-github]: https://github.com/open-telemetry/opentelemetry-ruby-contrib/blob/main/LICENSE
 [ruby-sig]: https://github.com/open-telemetry/community#ruby-sig
 [community-meetings]: https://github.com/open-telemetry/community#community-meetings
+[slack-channel]: https://cloud-native.slack.com/archives/C01NWKKMKMY
 [discussions-url]: https://github.com/open-telemetry/opentelemetry-ruby/discussions

data/lib/opentelemetry/instrumentation/aws_sdk/handler.rb

@@ -7,38 +7,31 @@
 module OpenTelemetry
   module Instrumentation
     module AwsSdk
-      # Generates Spans for all interactions with AwsSdk
+      # This handler supports specifically supports V2 and V3
+      # prior to Observability support released on 2024-09-03.
       class Handler < Seahorse::Client::Handler
-        SQS_SEND_MESSAGE = 'SQS.SendMessage'
-        SQS_SEND_MESSAGE_BATCH = 'SQS.SendMessageBatch'
-        SQS_RECEIVE_MESSAGE = 'SQS.ReceiveMessage'
-        SNS_PUBLISH = 'SNS.Publish'
-
         def call(context)
           return super unless context
 
-          service_name = service_name(context)
-          operation = context.operation&.name
-          client_method = "#{service_name}.#{operation}"
-          attributes = {
-            'aws.region' => context.config.region,
-            OpenTelemetry::SemanticConventions::Trace::RPC_SYSTEM => 'aws-api',
-            OpenTelemetry::SemanticConventions::Trace::RPC_METHOD => operation,
-            OpenTelemetry::SemanticConventions::Trace::RPC_SERVICE => service_name
-          }
-          attributes[SemanticConventions::Trace::DB_SYSTEM] = 'dynamodb' if service_name == 'DynamoDB'
-          MessagingHelper.apply_sqs_attributes(attributes, context, client_method) if service_name == 'SQS'
-          MessagingHelper.apply_sns_attributes(attributes, context, client_method) if service_name == 'SNS'
+          service_id = HandlerHelper.service_id(context, legacy: true)
+          client_method = HandlerHelper.client_method(service_id, context)
+
+          tracer.in_span(
+            HandlerHelper.span_name(context, client_method, service_id, legacy: true),
+            attributes: HandlerHelper.span_attributes(context, client_method, service_id, legacy: true),
+            kind: HandlerHelper.span_kind(client_method, service_id)
+          ) do |span|
+            MessagingHelper.inject_context_if_supported(context, client_method, service_id)
 
-          tracer.in_span(span_name(context, client_method), attributes: attributes, kind: span_kind(client_method)) do |span|
-            inject_context(context, client_method)
-            if instrumentation_config[:suppress_internal_instrumentation]
+            if HandlerHelper.instrumentation_config[:suppress_internal_instrumentation]
               OpenTelemetry::Common::Utilities.untraced { super }
             else
               super
             end.tap do |response|
-              span.set_attribute(OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE,
-                                 context.http_response.status_code)
+              span.set_attribute(
+                OpenTelemetry::SemanticConventions::Trace::HTTP_STATUS_CODE,
+                context.http_response.status_code
+              )
 
               if (err = response.error)
                 span.record_exception(err)
@@ -53,60 +46,11 @@ module OpenTelemetry
         def tracer
           AwsSdk::Instrumentation.instance.tracer
         end
-
-        def instrumentation_config
-          AwsSdk::Instrumentation.instance.config
-        end
-
-        def service_name(context)
-          # Support aws-sdk v2.0.x, which 'metadata' has a setter method only
-          return context.client.class.to_s.split('::')[1] if ::Seahorse::Model::Api.instance_method(:metadata).parameters.length.positive?
-
-          context.client.class.api.metadata['serviceId'] || context.client.class.to_s.split('::')[1]
-        end
-
-        SEND_MESSAGE_CLIENT_METHODS = [SQS_SEND_MESSAGE, SQS_SEND_MESSAGE_BATCH, SNS_PUBLISH].freeze
-        def inject_context(context, client_method)
-          return unless SEND_MESSAGE_CLIENT_METHODS.include? client_method
-          return unless instrumentation_config[:inject_messaging_context]
-
-          if client_method == SQS_SEND_MESSAGE_BATCH
-            context.params[:entries].each do |entry|
-              entry[:message_attributes] ||= {}
-              OpenTelemetry.propagation.inject(entry[:message_attributes], setter: MessageAttributeSetter)
-            end
-          else
-            context.params[:message_attributes] ||= {}
-            OpenTelemetry.propagation.inject(context.params[:message_attributes], setter: MessageAttributeSetter)
-          end
-        end
-
-        def span_kind(client_method)
-          case client_method
-          when SQS_SEND_MESSAGE, SQS_SEND_MESSAGE_BATCH, SNS_PUBLISH
-            OpenTelemetry::Trace::SpanKind::PRODUCER
-          when SQS_RECEIVE_MESSAGE
-            OpenTelemetry::Trace::SpanKind::CONSUMER
-          else
-            OpenTelemetry::Trace::SpanKind::CLIENT
-          end
-        end
-
-        def span_name(context, client_method)
-          case client_method
-          when SQS_SEND_MESSAGE, SQS_SEND_MESSAGE_BATCH, SNS_PUBLISH
-            "#{MessagingHelper.queue_name(context)} publish"
-          when SQS_RECEIVE_MESSAGE
-            "#{MessagingHelper.queue_name(context)} receive"
-          else
-            client_method
-          end
-        end
       end
 
       # A Seahorse::Client::Plugin that enables instrumentation for all AWS services
       class Plugin < Seahorse::Client::Plugin
-        def add_handlers(handlers, config)
+        def add_handlers(handlers, _config)
           # run before Seahorse::Client::Plugin::ParamValidator (priority 50)
           handlers.add Handler, step: :validate, priority: 49
         end

data/lib/opentelemetry/instrumentation/aws_sdk/handler_helper.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module AwsSdk
+      # Utility module that contains shared methods between AwsSdk and Telemetry handlers
+      module HandlerHelper
+        class << self
+          def instrumentation_config
+            AwsSdk::Instrumentation.instance.config
+          end
+
+          def client_method(service_id, context)
+            "#{service_id}.#{context.operation.name}".delete(' ')
+          end
+
+          def span_attributes(context, client_method, service_id, legacy: false)
+            {
+              'aws.region' => context.config.region,
+              OpenTelemetry::SemanticConventions::Trace::CODE_FUNCTION => context.operation_name.to_s,
+              OpenTelemetry::SemanticConventions::Trace::CODE_NAMESPACE => 'Aws::Plugins::Telemetry',
+              OpenTelemetry::SemanticConventions::Trace::RPC_METHOD => context.operation.name,
+              OpenTelemetry::SemanticConventions::Trace::RPC_SERVICE => service_id,
+              OpenTelemetry::SemanticConventions::Trace::RPC_SYSTEM => 'aws-api'
+            }.tap do |attrs|
+              attrs[OpenTelemetry::SemanticConventions::Trace::CODE_NAMESPACE] = 'Aws::Plugins::AwsSdk' if legacy
+              attrs[SemanticConventions::Trace::DB_SYSTEM] = 'dynamodb' if service_id == 'DynamoDB'
+
+              MessagingHelper.apply_span_attributes(context, attrs, client_method, service_id) if MessagingHelper::SUPPORTED_SERVICES.include?(service_id)
+            end
+          end
+
+          def span_kind(client_method, service_id)
+            case service_id
+            when *MessagingHelper::SUPPORTED_SERVICES
+              MessagingHelper.span_kind(client_method)
+            else
+              OpenTelemetry::Trace::SpanKind::CLIENT
+            end
+          end
+
+          def span_name(context, client_method, service_id, legacy: false)
+            case service_id
+            when *MessagingHelper::SUPPORTED_SERVICES
+              if legacy
+                MessagingHelper.legacy_span_name(context, client_method)
+              else
+                MessagingHelper.span_name(context, client_method)
+              end
+            else
+              client_method
+            end
+          end
+
+          def service_id(context, legacy: false)
+            if legacy
+              legacy_service_id(context)
+            else
+              context.config.api.metadata['serviceId'] ||
+                context.config.api.metadata['serviceAbbreviation'] ||
+                context.config.api.metadata['serviceFullName']
+            end
+          end
+
+          private
+
+          def legacy_service_id(context)
+            # Support aws-sdk v2.0.x, which 'metadata' has a setter method only
+            return context.client.class.to_s.split('::')[1] if ::Seahorse::Model::Api.instance_method(:metadata).parameters.length.positive?
+
+            context.client.class.api.metadata['serviceId'] || context.client.class.to_s.split('::')[1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/aws_sdk/instrumentation.rb

@@ -7,13 +7,39 @@
 module OpenTelemetry
   module Instrumentation
     module AwsSdk
-      # Instrumentation class that detects and installs the AwsSdk instrumentation
+      # The `OpenTelemetry::Instrumentation::AwsSdk::Instrumentation` class contains
+      # logic to detect and install the AwsSdk instrumentation.
+      #
+      # ## Configuration keys and options
+      #
+      # ### `:inject_messaging_context`
+      #
+      # Allows adding of context key/value to Message Attributes for SQS/SNS messages.
+      #
+      # - `false` **(default)** - Context key/value will not be added.
+      # - `true` - Context key/value will be added.
+      #
+      # ### `:suppress_internal_instrumentation`
+      #
+      # Disables tracing of spans of `internal` span kind.
+      #
+      # - `false` **(default)** - Internal spans are traced.
+      # - `true` - Internal spans are not traced.
+      #
+      # @example An explicit default configuration
+      #   OpenTelemetry::SDK.configure do |c|
+      #     c.use 'OpenTelemetry::Instrumentation::AwsSdk', {
+      #       inject_messaging_context: false,
+      #       suppress_internal_instrumentation: false
+      #     }
+      #   end
       class Instrumentation < OpenTelemetry::Instrumentation::Base
         MINIMUM_VERSION = Gem::Version.new('2.0.0')
 
         install do |_config|
           require_dependencies
-          add_plugin(Seahorse::Client::Base, *loaded_constants)
+          patch_telemetry_plugin if telemetry_plugin?
+          add_plugins(Seahorse::Client::Base, *loaded_service_clients)
         end
 
         present do
@@ -41,31 +67,61 @@ module OpenTelemetry
 
         def require_dependencies
           require_relative 'handler'
-          require_relative 'services'
+          require_relative 'handler_helper'
           require_relative 'message_attributes'
           require_relative 'messaging_helper'
+          require_relative 'patches/telemetry'
         end
 
-        def add_plugin(*targets)
-          targets.each { |klass| klass.add_plugin(AwsSdk::Plugin) }
+        def add_plugins(*targets)
+          targets.each do |klass|
+            next if supports_telemetry_plugin?(klass)
+
+            klass.add_plugin(AwsSdk::Plugin)
+          end
+        end
+
+        def supports_telemetry_plugin?(klass)
+          telemetry_plugin? &&
+            klass.plugins.include?(Aws::Plugins::Telemetry)
+        end
+
+        def telemetry_plugin?
+          ::Aws::Plugins.const_defined?(:Telemetry)
+        end
+
+        # Patches AWS SDK V3's telemetry plugin for integration
+        # This patch supports configuration set by this gem and
+        # additional span attributes that was not provided by the plugin
+        def patch_telemetry_plugin
+          ::Aws::Plugins::Telemetry::Handler.prepend(Patches::Handler)
         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)
+        def loaded_service_clients
+          ::Aws.constants.each_with_object([]) do |c, constants|
+            m = ::Aws.const_get(c)
+            next unless loaded_service?(c, m)
 
             begin
-              constants << ::Aws.const_get(service, false).const_get(:Client, false)
+              constants << m.const_get(:Client)
             rescue StandardError => e
               OpenTelemetry.logger.warn("Constant could not be loaded: #{e}")
             end
           end
         end
+
+        # This check does the following:
+        # 1 - Checks if the service client is autoload or not
+        # 2 - Validates whether if is a service client
+        # note that Seahorse::Client::Base is a superclass for V3 clients
+        # but for V2, it is Aws::Client
+        def loaded_service?(constant, service_module)
+          !::Aws.autoload?(constant) &&
+            service_module.is_a?(Module) &&
+            service_module.const_defined?(:Client) &&
+            (service_module.const_get(:Client).superclass == Seahorse::Client::Base ||
+              service_module.const_get(:Client).superclass == Aws::Client)
+        end
       end
     end
   end

data/lib/opentelemetry/instrumentation/aws_sdk/messaging_helper.rb

@@ -7,9 +7,20 @@
 module OpenTelemetry
   module Instrumentation
     module AwsSdk
-      # MessagingHelper class provides methods for calculating messaging span attributes
+      # An utility class to help SQS/SNS-related span attributes/context injection
       class MessagingHelper
+        SUPPORTED_SERVICES = %w[SQS SNS].freeze
         class << self
+          SQS_SEND_MESSAGE = 'SQS.SendMessage'
+          SQS_SEND_MESSAGE_BATCH = 'SQS.SendMessageBatch'
+          SQS_RECEIVE_MESSAGE = 'SQS.ReceiveMessage'
+          SNS_PUBLISH = 'SNS.Publish'
+          SEND_MESSAGE_CLIENT_METHODS = [SQS_SEND_MESSAGE, SQS_SEND_MESSAGE_BATCH, SNS_PUBLISH].freeze
+
+          def supported_services
+            SUPPORTED_SERVICES
+          end
+
           def queue_name(context)
             topic_arn = context.params[:topic_arn]
             target_arn = context.params[:target_arn]
@@ -28,19 +39,82 @@ module OpenTelemetry
             'unknown'
           end
 
+          def span_name(context, client_method)
+            case client_method
+            when SQS_SEND_MESSAGE, SQS_SEND_MESSAGE_BATCH, SNS_PUBLISH
+              "#{client_method}.#{queue_name(context)}.Publish"
+            when SQS_RECEIVE_MESSAGE
+              "#{client_method}.#{queue_name(context)}.Receive"
+            else
+              client_method
+            end
+          end
+
+          def legacy_span_name(context, client_method)
+            case client_method
+            when SQS_SEND_MESSAGE, SQS_SEND_MESSAGE_BATCH, SNS_PUBLISH
+              "#{MessagingHelper.queue_name(context)} publish"
+            when SQS_RECEIVE_MESSAGE
+              "#{MessagingHelper.queue_name(context)} receive"
+            else
+              client_method
+            end
+          end
+
+          def apply_span_attributes(context, attrs, client_method, service_id)
+            case service_id
+            when 'SQS'
+              apply_sqs_attributes(attrs, context, client_method)
+            when 'SNS'
+              apply_sns_attributes(attrs, context, client_method)
+            end
+          end
+
+          def span_kind(client_method)
+            case client_method
+            when SQS_SEND_MESSAGE, SQS_SEND_MESSAGE_BATCH, SNS_PUBLISH
+              OpenTelemetry::Trace::SpanKind::PRODUCER
+            when SQS_RECEIVE_MESSAGE
+              OpenTelemetry::Trace::SpanKind::CONSUMER
+            else
+              OpenTelemetry::Trace::SpanKind::CLIENT
+            end
+          end
+
+          def inject_context_if_supported(context, client_method, service_id)
+            if HandlerHelper.instrumentation_config[:inject_messaging_context] &&
+               SUPPORTED_SERVICES.include?(service_id)
+              inject_context(context, client_method)
+            end
+          end
+
+          def inject_context(context, client_method)
+            return unless SEND_MESSAGE_CLIENT_METHODS.include?(client_method)
+
+            if client_method == SQS_SEND_MESSAGE_BATCH
+              context.params[:entries].each do |entry|
+                entry[:message_attributes] ||= {}
+                OpenTelemetry.propagation.inject(entry[:message_attributes], setter: MessageAttributeSetter)
+              end
+            else
+              context.params[:message_attributes] ||= {}
+              OpenTelemetry.propagation.inject(context.params[:message_attributes], setter: MessageAttributeSetter)
+            end
+          end
+
+          private
+
           def apply_sqs_attributes(attributes, context, client_method)
             attributes[SemanticConventions::Trace::MESSAGING_SYSTEM] = 'aws.sqs'
             attributes[SemanticConventions::Trace::MESSAGING_DESTINATION_KIND] = 'queue'
             attributes[SemanticConventions::Trace::MESSAGING_DESTINATION] = queue_name(context)
             attributes[SemanticConventions::Trace::MESSAGING_URL] = context.params[:queue_url] if context.params[:queue_url]
-
-            attributes[SemanticConventions::Trace::MESSAGING_OPERATION] = 'receive' if client_method == 'SQS.ReceiveMessage'
+            attributes[SemanticConventions::Trace::MESSAGING_OPERATION] = 'receive' if client_method == SQS_RECEIVE_MESSAGE
           end
 
           def apply_sns_attributes(attributes, context, client_method)
             attributes[SemanticConventions::Trace::MESSAGING_SYSTEM] = 'aws.sns'
-
-            return unless client_method == 'SNS.Publish'
+            return unless client_method == SNS_PUBLISH
 
             attributes[SemanticConventions::Trace::MESSAGING_DESTINATION_KIND] = 'topic'
             attributes[SemanticConventions::Trace::MESSAGING_DESTINATION] = queue_name(context)

data/lib/opentelemetry/instrumentation/aws_sdk/patches/telemetry.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module OpenTelemetry
+  module Instrumentation
+    module AwsSdk
+      module Patches
+        # Patch for Telemetry Plugin Handler in V3 SDK
+        module Handler
+          def call(context)
+            span_wrapper(context) { @handler.call(context) }
+          end
+
+          private
+
+          def span_wrapper(context, &block)
+            service_id = HandlerHelper.service_id(context)
+            client_method = HandlerHelper.client_method(service_id, context)
+            context.tracer.in_span(
+              HandlerHelper.span_name(context, client_method, service_id),
+              attributes: HandlerHelper.span_attributes(context, client_method, service_id),
+              kind: HandlerHelper.span_kind(client_method, service_id)
+            ) do |span|
+              MessagingHelper.inject_context_if_supported(context, client_method, service_id)
+
+              if HandlerHelper.instrumentation_config[:suppress_internal_instrumentation]
+                OpenTelemetry::Common::Utilities.untraced { super }
+              else
+                yield span
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/opentelemetry/instrumentation/aws_sdk/version.rb

@@ -7,7 +7,7 @@
 module OpenTelemetry
   module Instrumentation
     module AwsSdk
-      VERSION = '0.5.4'
+      VERSION = '0.7.0'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opentelemetry-instrumentation-aws_sdk
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.7.0
 platform: ruby
 authors:
 - OpenTelemetry Authors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-24 00:00:00.000000000 Z
+date: 2024-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opentelemetry-api
@@ -156,28 +156,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.65.0
+        version: 1.66.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.65.0
+        version: 1.66.0
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.20'
+        version: 1.22.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.20'
+        version: 1.22.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -198,14 +198,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.19'
+        version: 3.24.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.19'
+        version: 3.24.0
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -235,19 +235,20 @@ files:
 - lib/opentelemetry/instrumentation.rb
 - lib/opentelemetry/instrumentation/aws_sdk.rb
 - lib/opentelemetry/instrumentation/aws_sdk/handler.rb
+- lib/opentelemetry/instrumentation/aws_sdk/handler_helper.rb
 - lib/opentelemetry/instrumentation/aws_sdk/instrumentation.rb
 - lib/opentelemetry/instrumentation/aws_sdk/message_attributes.rb
 - lib/opentelemetry/instrumentation/aws_sdk/messaging_helper.rb
-- lib/opentelemetry/instrumentation/aws_sdk/services.rb
+- lib/opentelemetry/instrumentation/aws_sdk/patches/telemetry.rb
 - lib/opentelemetry/instrumentation/aws_sdk/version.rb
 homepage: https://github.com/open-telemetry/opentelemetry-ruby-contrib
 licenses:
 - Apache-2.0
 metadata:
-  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-aws_sdk/0.5.4/file/CHANGELOG.md
+  changelog_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-aws_sdk/0.7.0/file/CHANGELOG.md
   source_code_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/tree/main/instrumentation/aws_sdk
   bug_tracker_uri: https://github.com/open-telemetry/opentelemetry-ruby-contrib/issues
-  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-aws_sdk/0.5.4
+  documentation_uri: https://rubydoc.info/gems/opentelemetry-instrumentation-aws_sdk/0.7.0
 post_install_message: 
 rdoc_options: []
 require_paths:

data/lib/opentelemetry/instrumentation/aws_sdk/services.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module OpenTelemetry
-  module Instrumentation
-    # rubocop:disable Metrics/ModuleLength:
-    module AwsSdk
-      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
-    end
-    # rubocop:enable Metrics/ModuleLength:
-  end
-end