aspecto-opentelemetry 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd25c9da7c25d1c4c7e7a389189e7f0369dc7b97120425eda7cf49d9fb344b42
-  data.tar.gz: '075783f49804d1e01c16b6b80d1c37ed3b0d1de4c05b6ed4f2cd19007c28ccfc'
+  metadata.gz: fa9f82192a245e9a33161f11750b16971a2d52e0732d5f880073e725a63061d3
+  data.tar.gz: 4a4e5f909cdae8aa42b094ea744951a72be1c3e3a8dedd0fdb39e591dea438e7
 SHA512:
-  metadata.gz: eb1b4410ae3dfa99e61592663cc1f4dff627908632f784fc39938b72a698a9f220e2ce88feb636402ae7a1c791b3395ad7dd5a376daa240ee0398f62961a25a2
-  data.tar.gz: 67606263a5e1dc5ecbf8375bd511fd97e9728dd8fd6fa259d746641abb8a488b8e88d81a0b72416a3aee8184c94f30f61e2600bda267cfba6d8a16d814b1d82a
+  metadata.gz: a1cd8000fbb795c64b710f875aadc79d9eba68be979c59009903c8dc98f1bacb4e24125da4f8266e1ceac4e70ac280f1fcddf1dc56876c857c4064c01a92b12c
+  data.tar.gz: 6b78f002233939baca74d7871d7a80464a6fc9441ecdc553f9acd7419791bf2fdc9b8a6052dcee3d9363255d5742ddb41a500304e20c821184dce281141f871b

data/README.md

@@ -1,76 +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_SERIVCE_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_SERIVCE_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_SERIVCE_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
+Add this require statement after your require other gems:
 
-You can set configuration it 2 ways: via environment variables or via code.
-The only required config options are `aspecto_auth` and `service_name`.
+```rb
+require 'aspecto/auto_instrument'
+```
 
-### Configuration in Code
+And set environment variables:
 
-```rb
-require 'aspecto/opentelemetry'
+```
+OTEL_SERVICE_NAME=<YOUR_SERIVCE_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
+```
 
-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
+### Shutdown
+
+Call this function when your application shuts down
+
+```rb
+Aspecto::OpenTelemetry::shutdown
 ```
 
-### Configuration Options
+## 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`.
 
-| 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 |
+### Configuration Options
 
+| 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

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

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "./sampling_rule"
-require_relative "./utils"
+require_relative "./operator"
 
 module Aspecto
   # Aspecto OpenTelemetry Distro
@@ -11,21 +11,25 @@ module Aspecto
       class RulesSampler
         def initialize(config, fallback_sampler, service_name, env)
           @rules = config
-                   .select { |rule| Sampler.meets_operator?(rule["packageName"]["comparison"].to_sym, rule["packageName"]["value"], service_name) }
-                   .select { |rule| Sampler.meets_operator?(rule["env"]["comparison"].to_sym, rule["env"]["value"], env) }
+                   .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:)
-          matching_rule = @rules.find { |rule| rule.satisfied?(attributes, name) }
-          delegate_sampler = matching_rule ? matching_rule.sampler : @fallback_sampler
+          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

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

@@ -13,12 +13,13 @@ module Aspecto
           @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
+        attr_reader :sampler, :context
 
-        def satisfied?(attributes, span_name)
-          @conditions.all? { |condition| condition.satisfied?(attributes, span_name) }
+        def satisfies?(attributes, span_name)
+          @conditions.all? { |condition| condition.satisfies?(attributes, span_name) }
         end
       end
     end

data/lib/aspecto/opentelemetry/version.rb

@@ -2,6 +2,6 @@
 
 module Aspecto
   module OpenTelemetry
-    VERSION = "0.1.1"
+    VERSION = "0.1.2"
   end
 end

data/lib/aspecto/opentelemetry.rb

@@ -4,8 +4,7 @@ require_relative "opentelemetry/version"
 require_relative "opentelemetry/configurator"
 require_relative "opentelemetry/resource/detectors/aspecto"
 require_relative "opentelemetry/resource/detectors/deployment"
-require_relative "opentelemetry/remote_config"
-require_relative "opentelemetry/sampler/rules_sampler"
+require_relative "opentelemetry/config/remote_config"
 
 require "opentelemetry/sdk"
 require "opentelemetry/exporter/otlp"
@@ -33,34 +32,39 @@ module Aspecto
         c.use_all "OpenTelemetry::Instrumentation::ActionPack" => { enable_recognize_route: true },
                   "OpenTelemetry::Instrumentation::AwsSdk" => { suppress_internal_instrumentation: true }
 
-        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
-                                                          })
-          )
-        )
+        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
 
         at_exit do
-          ::OpenTelemetry.tracer_provider.shutdown
+          # 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
 
       fallback_sampler = ::OpenTelemetry::SDK::Trace::Samplers.trace_id_ratio_based(configurator.sampling_ratio)
-      remote_config = fetch_config configurator.aspecto_auth
       # 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 }
-      rules_sampler = Sampler::RulesSampler.new remote_config["samplingRules"], fallback_sampler, service_name, env
-      ::OpenTelemetry.tracer_provider.sampler = ::OpenTelemetry::SDK::Trace::Samplers.parent_based(root: rules_sampler)
+      @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,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: aspecto-opentelemetry
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Aspecto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-23 00:00:00.000000000 Z
+date: 2021-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: aspecto-opentelemetry-instrumentation-aws_sdk
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 0.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: 0.1.5
 - !ruby/object:Gem::Dependency
-  name: faraday_middleware
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
-  name: aspecto-opentelemetry-instrumentation-aws_sdk
+  name: faraday_middleware
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.4
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: opentelemetry-exporter-otlp
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +94,20 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: '1.0'
+- !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
@@ -108,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.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.19.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -122,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
@@ -151,14 +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/remote_config.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/sampler/utils.rb
 - lib/aspecto/opentelemetry/version.rb
 homepage: https://docs.aspecto.io/
 licenses:

data/lib/aspecto/opentelemetry/remote_config.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "faraday_middleware"
-
-module Aspecto
-  # Aspecto's OpenTelemetry distribution
-  module OpenTelemetry
-    def self.fetch_config(aspecto_auth)
-      aspecto_config_url = ENV["ASPECTO_CONFIG_HOST"] || "https://config.aspecto.io"
-
-      conn = Faraday.new "#{aspecto_config_url}/config/#{aspecto_auth}" do |f|
-        f.response :json # decode response bodies as JSON
-      end
-
-      ::OpenTelemetry::Common::Utilities.untraced do
-        response = conn.get
-        response.body
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Aspecto
-  # Aspecto OpenTelemetry Distro
-  module OpenTelemetry
-    # Sampling logic for aspecto otel distribution
-    module Sampler
-      extend self
-
-      def meets_operator?(operator, expected, actual) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
-        expected_lower = expected&.downcase
-        actual_lower = actual&.downcase
-        case operator
-        when :eq
-          expected_lower == actual_lower
-        when :ne
-          expected_lower != actual_lower
-        when :starts_with
-          actual_lower.start_with?(expected_lower)
-        when :ends_with
-          actual_lower.end_with?(expected_lower)
-        when :contains
-          actual_lower.include?(expected_lower)
-        when :not_contains
-          !actual_lower.include?(expected_lower)
-        when :matches
-          Regexp.new(expected_lower).match(actual_lower)
-        when :defined
-          !actual.nil?
-        when :undefined
-          actual.nil?
-        when :any
-          true
-        else
-          false
-        end
-      end
-    end
-  end
-end