aspecto-opentelemetry 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2bcc099a425ea9d9d4ea5279fcdde5fd1c72ee7a747cac0db749ec4946e6400
-  data.tar.gz: 4045a1f967fc690eb67d057311f8543924abb14a223fd6484135e3831bc1fa11
+  metadata.gz: 1b300da76183578ab46935f20f8910aba9c73e19734f8ca19e83a5d0886dd09f
+  data.tar.gz: cd326d3a7855570df0fa90fa3a7ea7be7431f7554efa7292166d83fdcbbb7b99
 SHA512:
-  metadata.gz: 5abe512f0a006febca0d20dab3dc2600539ef5af63429e3f05e715278e2760f611cc85908176a08e84a5570a045d02fd6baba260a8b769b691e9ad13f8d29abd
-  data.tar.gz: f37300481a7a2994eb99600ed22fd122abaae7afe2569f36beb342f79204320b8726125fdb226adf1114169b178f6b7f43ff93c482c3d8b682681c9503d4579a
+  metadata.gz: da49265bb04f5d7f67a82f26d4ce14e2812602238e1fe9b5d4c83a68b010831215ddde521d62ad85175672730bf922e53bfcfe9d90728a136464c01873fa937d
+  data.tar.gz: 6ba067f0aeca189748bfe2e129a3bed4d01f0e59604ced9890948f7fd097c2869db1eae91192bc44ae7e31731e7691c4f48264c5992fd60f0b3cb646abaeb2a6

data/README.md

@@ -1,81 +1,110 @@
 # Aspecto::OpenTelemetry
 
-Aspecto's SDK for ruby. This gem is a distribution of OpenTelemetry configured to use all available instrumentations and export trace data to Aspecto.
+Aspecto's SDK for ruby.  
+This gem is a distribution of OpenTelemetry pre-configured to use all available instrumentations and export trace data to Aspecto.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install the gem using:
 
-```ruby
-gem 'aspecto-opentelemetry'
+```zsh
+$ gem install aspecto-opentelemetry
 ```
 
-And then execute:
+Or, if you use [bundler](https://bundler.io), include aspecto-opentelemetry in your Gemfile.
 
-    $ bundle install
+## Usage
 
-Or install it yourself as:
+### Rails Applications
 
-    $ gem install aspecto-opentelemetry
+#### Configuration in Code
 
-## Usage
+Add this code to a new file `aspecto.rb` under `config/initializers/`:
+
+```rb
+# config/initializers/aspecto.rb
+require 'aspecto/opentelemetry'
+
+Aspecto::OpenTelemetry::configure do |c|
+  c.service_name = '<YOUR_SERVICE_NAME>'
+  c.aspecto_auth = '<YOUR_ASPECTO_TOKEN>'
+  # c.sampling_ratio = 1.0 # [optional]: defaults to 1.0, use aspecto app to configure remotely
+end
+```
 
-### Auto Instrumentation
+#### Configuration via Environment Variables
 
-Does not require code changes. Just modify you `Gemfile` to add `require` like this:
+In your Gemfile:
 
 ```
 gem 'aspecto-opentelemetry', require: 'aspecto/auto_instrument'
 ```
 
-When using auto-instrumentation, you need to pass relevant configuration options via environment variables.
+And set environment variables:
+
+```
+OTEL_SERVICE_NAME=<YOUR_SERVICE_NAME>
+ASPECTO_AUTH=<YOUR_ASPECTO_TOKEN>
+# ASPECTO_SAMPLING_RATIO=1.0 # [optional]: defaults to 1.0, use aspecto app to configure remotely
+```
+
+### Ruby Applications
 
-### Manual Instrumentation
+#### Configuration in Code
 
-Allow you to configure the SDK via code:
+Add this code after your require other gems:
 
 ```rb
 require 'aspecto/opentelemetry'
 
-Aspecto::OpenTelemetry::configure
+Aspecto::OpenTelemetry::configure do |c|
+  c.service_name = '<YOUR_SERVICE_NAME>'
+  c.aspecto_auth = '<YOUR_ASPECTO_TOKEN>'
+  # c.env = '<CURRENT_ENVIRONMENT>' # [optional]: automatically detected for rails and sinatra
+  # c.sampling_ratio = 1.0 # [optional]: defaults to 1.0, use aspecto app to configure remotely
+end
 ```
 
-Add this code at the beginning of your application.
-For rails - add this code to a file `aspecto.rb` under `config/initializers/`.
+#### Configuration via Environment Variables
 
-## Configuration
-
-You can set configuration it 2 ways: via environment variables or via code.
-The only required config options are `aspecto_auth` and `service_name`.
-
-### Configuration in Code
+Add this require statement after your require other gems:
 
 ```rb
-require 'aspecto/opentelemetry'
+require 'aspecto/auto_instrument'
+```
 
-Aspecto::OpenTelemetry::configure do |c|
-  c.service_name = 'MY_SERIVCE'
-  c.aspecto_auth = 'YOUR_TOKEN_HERE'
-  c.env = 'MY_COOL_ENV'
-  c.sampling_ratio = 0.1
-end
+And set environment variables:
+
+```
+OTEL_SERVICE_NAME=<YOUR_SERVICE_NAME>
+ASPECTO_AUTH=<YOUR_ASPECTO_TOKEN>
+# ASPECTO_ENV=<CURRENT_ENVIRONMENT> # [optional]: automatically detected for rails and sinatra
+# ASPECTO_SAMPLING_RATIO=1.0 # [optional]: defaults to 1.0, use aspecto app to configure remotely
 ```
 
-### Configuration Options
+### Shutdown
 
-| Option Name    | Environment Variable   | Type        | Default                                                                                                                                              | Description                                                                            |
-| -------------- | ---------------------- | ----------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- |
-| aspecto_auth   | ASPECTO_AUTH           | UUID string | -                                                                                                                                                    | Aspecto's [API key for authentication](https://app.aspecto.io/app/integration/api-key) |
-| service_name   | OTEL_SERVICE_NAME      | string      | -                                                                                                                                                    | name of the service which is sending telemetry                                         |
-| env            | ASPECTO_ENV            | string      | extracted from rails or sinatra if used                                                                                                              | deployment environment: `"production"` / `"staging"` / `"development"`, etc.           |
-| log_level            | OTEL_LOG_LEVEL            | string      | 'ERROR'         | `"ERROR"` / `"WARN"` / `"INFO"`, etc.           |
-| sampling_ratio | ASPECTO_SAMPLING_RATIO | float    |  1.0   | How many of the traces starting in this service should be sampled. set to number in range [0.0, 1.0] where 0.0 is no sampling, and 1.0 is sample all |
+Call this function when your application shuts down
 
-## Development
+```rb
+Aspecto::OpenTelemetry::shutdown
+```
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Configuration
+
+You can set configuration via environment variables or via code. Values set in code takes precedence.
+The only required config options are [`aspecto_auth`](https://app.aspecto.io/app/integration/api-key) and `service_name`.
+
+### Configuration Options
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+| Option Name                          | Environment Variable                 | Type        | Default                                 | Description                                                                                                                                          |
+| ------------------------------------ | ------------------------------------ | ----------- | --------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `aspecto_auth`                       | `ASPECTO_AUTH`                       | UUID string | -                                       | Aspecto's [API key for authentication](https://app.aspecto.io/app/integration/api-key)                                                               |
+| `service_name`                       | `OTEL_SERVICE_NAME`                  | string      | -                                       | name of the service which is sending telemetry                                                                                                       |
+| `env`                                | `ASPECTO_ENV`                        | string      | extracted from rails or sinatra if used | deployment environment: `production` / `staging` / `development`, etc.                                                                               |
+| `log_level`                          | `OTEL_LOG_LEVEL`                     | string      | `ERROR`                                 | `ERROR` / `WARN` / `INFO`, etc.                                                                                                                      |
+| `sampling_ratio`                     | `ASPECTO_SAMPLING_RATIO`             | float       | 1.0                                     | How many of the traces starting in this service should be sampled. set to number in range [0.0, 1.0] where 0.0 is no sampling, and 1.0 is sample all |
+| `otel_exporter_otlp_traces_endpoint` | `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT` | URL         | "https://otelcol.aspecto.io/v1/trace"   | Url                                                                                                                                                  |
 
 ## Contributing
 

data/lib/aspecto/opentelemetry/config/remote_config.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday_middleware"
+require "rufus/scheduler"
+
+require_relative "../sampler/rules_sampler"
+require_relative "../sampler/message_process_sampler"
+
+module Aspecto
+  # Aspecto's OpenTelemetry distribution
+  module OpenTelemetry
+    module Config
+      # Handle fetching of remote configuration from aspecto
+      class RemoteConfig
+        def initialize(aspecto_auth, service_name, env, fallback_sampler)
+          @service_name = service_name
+          @env = env
+          @fallback_sampler = fallback_sampler
+
+          aspecto_config_url = ENV.fetch("ASPECTO_CONFIG_HOST", "https://config.aspecto.io")
+          @http_client = Faraday.new "#{aspecto_config_url}/config/#{aspecto_auth}" do |f|
+            f.response :json # decode response bodies as JSON
+          end
+          @http_client.options.timeout = 10
+
+          @scheduler = Rufus::Scheduler.new
+          @remote_config_poll_frequency = ENV.fetch("ASPECTO_REMOTE_CONFIG_POLL_FREQUENCY", "30s")
+          @scheduler.interval @remote_config_poll_frequency, first: :now do
+            update_config
+          end
+
+          ::OpenTelemetry.logger.info "[Aspecto] SDK client initialized"
+        end
+
+        def shutdown
+          @scheduler.shutdown
+        end
+
+        private
+
+        def update_config # rubocop:disable Metrics/AbcSize
+          ::OpenTelemetry::Common::Utilities.untraced do
+            response = @http_client.get do |req|
+              req.headers["If-None-Match"] = @latest_config_etag unless @latest_config_etag.nil?
+            end
+            @latest_config_etag = response.headers["etag"]
+            return if response.status == 304
+
+            if response.status >= 400
+              ::OpenTelemetry.logger.error("[Aspecto] error when trying to get remote config. will try again in #{@remote_config_poll_frequency}")
+              return
+            end
+            handle_new_config response.body if response.status < 300
+          end
+        rescue StandardError => e
+          ::OpenTelemetry.logger.error "[Aspecto] updating remote config failed. using previous remote config"
+          ::OpenTelemetry.logger.debug e
+        end
+
+        def handle_new_config(config)
+          ::OpenTelemetry.logger.info("[Aspecto] successfully received remote configuration")
+          update_sampler config["samplingRules"]
+        end
+
+        def update_sampler(sampler_config)
+          rules_sampler = Sampler::RulesSampler.new sampler_config, @fallback_sampler, @service_name, @env
+          service_sampler = ::OpenTelemetry::SDK::Trace::Samplers.parent_based(root: rules_sampler)
+          message_process_sampler = Sampler::MessageProcessSampler.new rules_sampler, service_sampler
+          # updating the sampler should be thread safe as it's an atomic setter on a global value
+          ::OpenTelemetry.tracer_provider.sampler = message_process_sampler
+        end
+      end
+    end
+  end
+end

data/lib/aspecto/opentelemetry/configurator.rb

@@ -13,6 +13,7 @@ module Aspecto
         self.log_level = ENV.fetch("OTEL_LOG_LEVEL", Logger::ERROR)
         self.env = ENV["ASPECTO_ENV"] if ENV["ASPECTO_ENV"]
         self.sampling_ratio = Float(ENV.fetch("ASPECTO_SAMPLING_RATIO", 1.0))
+        self.otel_exporter_otlp_traces_endpoint = ENV.fetch("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", "https://otelcol.aspecto.io/v1/trace")
       end
 
       def service_name=(service_name)
@@ -23,7 +24,7 @@ module Aspecto
         @override_resource_attributes[::OpenTelemetry::SemanticConventions::Resource::DEPLOYMENT_ENVIRONMENT] = env
       end
 
-      attr_accessor :sampling_ratio, :log_level
+      attr_accessor :sampling_ratio, :log_level, :otel_exporter_otlp_traces_endpoint
       attr_reader :aspecto_auth
 
       def aspecto_auth=(aspecto_auth)

data/lib/aspecto/opentelemetry/sampler/condition.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "./operator"
+
+module Aspecto
+  # Aspecto OpenTelemetry Distro
+  module OpenTelemetry
+    module Sampler
+      # Aspecto's sampling rule condition
+      class Condition
+        def initialize(condition_config)
+          @operator = Operator.new condition_config["comparison"], condition_config["value"]
+          @from = condition_config["from"]&.to_sym
+          @key = condition_config["key"]
+        end
+
+        def satisfies?(attributes, span_name)
+          case @from
+          when :attribute
+            @operator.satisfies? attributes&.[](@key)&.to_s
+          when :operation
+            @operator.satisfies? span_name
+          else
+            # Other "from" are not implemented for now
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/aspecto/opentelemetry/sampler/message_process_sampler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "opentelemetry/semantic_conventions"
+require "opentelemetry-api"
+
+module Aspecto
+  # Aspecto OpenTelemetry Distro
+  module OpenTelemetry
+    module Sampler
+      # OpenTelemetry sampler which implements the remote rules logic with fallback to service sampler
+      class MessageProcessSampler
+        def initialize(rules_sampler, service_sampler)
+          @rules_sampler = rules_sampler
+          @service_sampler = service_sampler
+        end
+
+        def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+          if attributes && attributes[::OpenTelemetry::SemanticConventions::Trace::MESSAGING_OPERATION] == "process"
+            sampling_decision = should_sample_processing(parent_context, links, name, attributes)
+            return sampling_decision if sampling_decision
+          end
+          @service_sampler.should_sample?(trace_id: trace_id, parent_context: parent_context, links: links, name: name, kind: kind, attributes: attributes)
+        end
+
+        def description
+          "MessageProcessSampler"
+        end
+
+        private
+
+        def should_sample_processing(parent_context, links, name, attributes)
+          return if links.length.zero?
+
+          decision = link_decision(links[0])
+
+          # sidekiq receive side is a single "process" span which is the entry for the trace
+          is_root = ::OpenTelemetry::Trace.current_span(parent_context) == ::OpenTelemetry::Trace::Span::INVALID
+          if is_root # rubocop:disable Style/GuardClause
+            matched_rule = @rules_sampler.matching_rule(name: name, attributes: attributes)
+            rule_context = matched_rule&.context
+            return ::OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: decision, tracestate: ::OpenTelemetry::Trace.current_span(parent_context).context.tracestate) if rule_context && rule_context["messaging.sampling.inherit_from_publisher"]
+          end
+
+          # if not root, then we need to check if the entry span set "messaging.sampling.inherit_from_publisher" on the context.
+          # since we currently only support sidekiq, it is not needed.
+          # but in the future, it can be implemented with context.attach when the rule is applied, and context.get here
+        end
+
+        def link_decision(link)
+          publisher_sampled = link.span_context.trace_flags.sampled?
+          publisher_sampled ? ::OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_AND_SAMPLE : ::OpenTelemetry::SDK::Trace::Samplers::Decision::DROP
+        end
+      end
+    end
+  end
+end

data/lib/aspecto/opentelemetry/sampler/operator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aspecto
+  # Aspecto OpenTelemetry Distro
+  module OpenTelemetry
+    # Sampling logic for aspecto otel distribution
+    module Sampler
+      # A single operator used to evaluate sampling rules
+      class Operator
+        def initialize(operator, expected)  # rubocop:disable Metrics/AbcSize
+          @expected = expected&.downcase
+          @expected = Regexp.new(@expected) if operator == "matches"
+
+          operator_to_proc = {
+            "eq" => proc { |actual| @expected == actual },
+            "ne" => proc { |actual| @expected != actual },
+            "starts_with" => proc { |actual| actual&.start_with?(expected) },
+            "ends_with" => proc { |actual| actual&.end_with?(expected) },
+            "contains" => proc { |actual| actual&.include?(expected) },
+            "not_contains" => proc { |actual| !actual&.include?(expected) },
+            "matches" => proc { |actual| @expected.match(actual) },
+            "defined" => proc { |actual| !actual.nil? },
+            "undefined" => proc { |actual| actual.nil? },
+            "any" => proc { true }
+          }
+
+          @evaluate = operator_to_proc.fetch(operator, proc { false })
+        end
+
+        def satisfies?(actual)
+          @evaluate.call actual&.downcase
+        end
+      end
+    end
+  end
+end

data/lib/aspecto/opentelemetry/sampler/rules_sampler.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "./sampling_rule"
+require_relative "./operator"
+
+module Aspecto
+  # Aspecto OpenTelemetry Distro
+  module OpenTelemetry
+    module Sampler
+      # OpenTelemetry sampler which implements the remote rules logic with fallback to service sampler
+      class RulesSampler
+        def initialize(config, fallback_sampler, service_name, env)
+          @rules = config
+                   .select { |rule| Operator.new(rule["packageName"]["comparison"], rule["packageName"]["value"]).satisfies?(service_name) }
+                   .select { |rule| Operator.new(rule["env"]["comparison"], rule["env"]["value"]).satisfies?(env) }
+                   .map { |rule_config| SamplingRule.new rule_config }
+          @fallback_sampler = fallback_sampler
+        end
+
+        def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+          rule = matching_rule(name: name, attributes: attributes)
+          delegate_sampler = rule ? rule.sampler : @fallback_sampler
+          delegate_sampler.should_sample?(trace_id: trace_id, parent_context: parent_context, links: links, name: name, kind: kind, attributes: attributes)
+        end
+
+        def description
+          "RulesSampler {#{rules.length} rules}"
+        end
+
+        def matching_rule(name:, attributes:)
+          @rules.find { |rule| rule.satisfies?(attributes, name) }
+        end
+      end
+    end
+  end
+end

data/lib/aspecto/opentelemetry/sampler/sampling_rule.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "opentelemetry/sdk"
+require_relative "./condition"
+
+module Aspecto
+  # Aspecto OpenTelemetry Distro
+  module OpenTelemetry
+    module Sampler
+      # Single rule for sampling
+      class SamplingRule
+        def initialize(rule_config)
+          @id = rule_config["_id"]
+          @sampler = ::OpenTelemetry::SDK::Trace::Samplers.trace_id_ratio_based(rule_config["samplingRate"])
+          @conditions = rule_config["conditions"].map { |condition_config| Condition.new condition_config }
+          @context = rule_config["context"]
+        end
+
+        attr_reader :sampler, :context
+
+        def satisfies?(attributes, span_name)
+          @conditions.all? { |condition| condition.satisfies?(attributes, span_name) }
+        end
+      end
+    end
+  end
+end

data/lib/aspecto/opentelemetry/version.rb

@@ -2,6 +2,6 @@
 
 module Aspecto
   module OpenTelemetry
-    VERSION = "0.1.0"
+    VERSION = "0.1.4"
   end
 end

data/lib/aspecto/opentelemetry.rb

@@ -4,6 +4,8 @@ require_relative "opentelemetry/version"
 require_relative "opentelemetry/configurator"
 require_relative "opentelemetry/resource/detectors/aspecto"
 require_relative "opentelemetry/resource/detectors/deployment"
+require_relative "opentelemetry/config/remote_config"
+
 require "opentelemetry/sdk"
 require "opentelemetry/exporter/otlp"
 require "opentelemetry/instrumentation/all"
@@ -28,26 +30,41 @@ module Aspecto
         c.resource = Aspecto::OpenTelemetry::Resource::Detectors::Deployment.detect
         c.resource = configurator.config_override_resource # must be last
         c.use_all "OpenTelemetry::Instrumentation::ActionPack" => { enable_recognize_route: true },
-                  "OpenTelemetry::Instrumentation::AwsSdk" => { suppress_internal_instrumentation: true }
+                  "OpenTelemetry::Instrumentation::AwsSdk" => { suppress_internal_instrumentation: true, inject_messaging_context: true }
+
+        otlp_exporter = ::OpenTelemetry::Exporter::OTLP::Exporter.new(endpoint: configurator.otel_exporter_otlp_traces_endpoint, headers: {
+                                                                        "Authorization" => configurator.aspecto_auth
+                                                                      })
+        span_processor = ::OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new otlp_exporter
+        c.add_span_processor span_processor
 
-        c.add_span_processor(
-          ::OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
-            ::OpenTelemetry::Exporter::OTLP::Exporter.new(endpoint: "https://otelcol.aspecto.io/v1/trace", headers: {
-                                                            "Authorization" => configurator.aspecto_auth
-                                                          })
-          )
-        )
+        at_exit do
+          # at_exit might be call when service terminates
+          # but can also be the initiator or the application like with sinatra:
+          # https://github.com/sinatra/sinatra/blob/cd503e6c590cd48c2c9bb7869522494bfc62cb14/lib/sinatra/main.rb#L25
+          span_processor.force_flush timeout: 2
+        end
       end
 
-      ::OpenTelemetry.tracer_provider.sampler = ::OpenTelemetry::SDK::Trace::Samplers.parent_based(root: ::OpenTelemetry::SDK::Trace::Samplers.trace_id_ratio_based(configurator.sampling_ratio))
+      fallback_sampler = ::OpenTelemetry::SDK::Trace::Samplers.trace_id_ratio_based(configurator.sampling_ratio)
+      # TODO: how to properly extract the data from resource?
+      _, service_name = ::OpenTelemetry.tracer_provider.resource.attribute_enumerator.detect { |elem| elem[0] == ::OpenTelemetry::SemanticConventions::Resource::SERVICE_NAME }
+      _, env = ::OpenTelemetry.tracer_provider.resource.attribute_enumerator.detect { |elem| elem[0] == ::OpenTelemetry::SemanticConventions::Resource::DEPLOYMENT_ENVIRONMENT }
+      @remote_config_service = Config::RemoteConfig.new configurator.aspecto_auth, service_name, env, fallback_sampler
     rescue StandardError => e
       warn "Failed to initialize Aspecto tracing."
       warn e
     end
 
+    def shutdown
+      ::OpenTelemetry.logger.info("Aspecto is shuting down. tracing is now stopped")
+      ::OpenTelemetry.tracer_provider.shutdown
+      @remote_config_service&.shutdown
+    end
+
     def validate_configurator_options(configurator)
       # aspecto_auth
-      unless configurator.aspecto_auth.instance_of?(String)
+      unless configurator.aspecto_auth.instance_of?(String) && !configurator.aspecto_auth.empty?
         raise "
     Unable to retrieve Aspecto token.
     In order for the Aspecto service to work, it requires an auth token.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aspecto-opentelemetry
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Aspecto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-23 00:00:00.000000000 Z
+date: 2021-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aspecto-opentelemetry-instrumentation-aws_sdk
@@ -16,56 +16,98 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: 0.1.7
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.1.3
+        version: 0.1.7
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-exporter-otlp
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.20.6
+        version: 0.21.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.20.6
+        version: 0.21.0
 - !ruby/object:Gem::Dependency
   name: opentelemetry-instrumentation-all
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.21.3
+        version: 0.22.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.21.3
+        version: 0.22.0
 - !ruby/object:Gem::Dependency
   name: opentelemetry-sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +122,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-common
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.3
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -123,9 +193,15 @@ files:
 - Rakefile
 - lib/aspecto/auto_instrument.rb
 - lib/aspecto/opentelemetry.rb
+- lib/aspecto/opentelemetry/config/remote_config.rb
 - lib/aspecto/opentelemetry/configurator.rb
 - lib/aspecto/opentelemetry/resource/detectors/aspecto.rb
 - lib/aspecto/opentelemetry/resource/detectors/deployment.rb
+- lib/aspecto/opentelemetry/sampler/condition.rb
+- lib/aspecto/opentelemetry/sampler/message_process_sampler.rb
+- lib/aspecto/opentelemetry/sampler/operator.rb
+- lib/aspecto/opentelemetry/sampler/rules_sampler.rb
+- lib/aspecto/opentelemetry/sampler/sampling_rule.rb
 - lib/aspecto/opentelemetry/version.rb
 homepage: https://docs.aspecto.io/
 licenses: