speedshop-cloudwatch 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb7393054526aee599b81c7f6031475244449ec5e2f6137f509b0fde8811c496
-  data.tar.gz: 45eababb5f976f5fe8eeacf13d43a13e1edc3a06b3a57e5f7a127ffa0385324e
+  metadata.gz: a4d2d47eedd3f9ad965073f7569d707bee70f2b4bb35f7b7f97f4197d9016b9c
+  data.tar.gz: d2bc25a79ba9893fa45a8a8843949ef42a7e70b5ab054ced8031446148bed927
 SHA512:
-  metadata.gz: f09b6d50481cb2ea0bb2d25a01fe93955321c1f528145a6e864b959d81724e87067e0851d8dd13d78d3864bbf60d6342bba737696350d2f10be50f6b5e06f1ec
-  data.tar.gz: 9c719ebf214f5112f95c15b31327ef71dff873b5eeb71ac2c5fbdf2ad1dffcba908abb74867f1429406095b8c7b3712d999650a8ca6d38af6be405ac68cd426e
+  metadata.gz: ae73508f29611fba12c522b3e84d82331026638892d2b540ede54a951a9e5314254c59a1620f5d423c0f592a7017f526233b938873107348231faf0a8db1c4b6
+  data.tar.gz: eb65e33a190b8d4a33686dd2c63f59ba504b0f585a2cb3d730f09274e89809acfa9ba0034caaef272b4f02fe3a0029c1373f03f684c9d3db2e03e4f1e9b8eab2

data/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.1] - 2026-06-09
+
+### Fixed
+- Improved Rack request queue time parsing for common `X-Request-Start` and `X-Queue-Start` formats, including `t=` prefixes, seconds, milliseconds, microseconds, and comma-separated header values.
+- Subtracted Puma request body wait time from Rack queue time when `env["puma.request_body_wait"]` is available, so slow uploads are not counted as upstream queueing.
+
+## [0.2.0] - 2026-04-13
+
+### Added
+- Added an optional Yabeda adapter so Yabeda-defined metrics can be delivered through the gem's async CloudWatch reporter pipeline.
+
+### Changed
+- Reduced CloudWatch metric cardinality and cost by removing the `WorkerIndex`, `Tag`, and `Hostname` dimensions from the affected Puma and Sidekiq metrics.
+
+### Upgrade Notes
+- Existing CloudWatch dashboards or alarms that filter on `WorkerIndex`, `Tag`, or `Hostname` dimensions will need to be updated before upgrading.
+
+## [0.1.0] - 2025-11-17
+
+### Added
+- Initial public release.
+
+[0.2.1]: https://github.com/speedshop/speedshop-cloudwatch/compare/v0.2.0...v0.2.1
+[0.2.0]: https://github.com/speedshop/speedshop-cloudwatch/compare/v0.1.0...v0.2.0
+[0.1.0]: https://github.com/speedshop/speedshop-cloudwatch/releases/tag/v0.1.0

data/README.md

@@ -49,6 +49,12 @@ config.metrics[:sidekiq] = [
 gem 'speedshop-cloudwatch'
 ```
 
+If you want to export metrics defined with Yabeda's DSL through this gem, also add:
+
+```ruby
+gem 'yabeda'
+```
+
 See each integration below for instructions on how to setup and configure that integration.
 
 ## Configuration
@@ -138,7 +144,9 @@ If you're using Rails, we'll automatically insert the correct middleware into th
 
 If you're using some other Rack-based framework, insert the `Speedshop::Cloudwatch::Rack` high up (i.e. first) in the stack.
 
-You will need a reverse proxy, such as nginx, adding an `X-Request-Start` or `X-Queue-Start` header (containing the time since the Unix epoch in milliseconds) to incoming requests. See [New Relic's instructions](https://docs.newrelic.com/docs/apm/applications-menu/features/configure-request-queue-reporting/) for more about how to do this.
+You will need a reverse proxy, such as nginx, adding an `X-Request-Start` or `X-Queue-Start` header to incoming requests. The header may use common queue-time formats such as epoch milliseconds (`1512379167574`), seconds with decimals (`t=1512379167.574`), or microseconds (`t=1570633834463123`). See [New Relic's instructions](https://docs.newrelic.com/docs/apm/applications-menu/features/configure-request-queue-reporting/) for more about how to do this.
+
+When Puma exposes `env["puma.request_body_wait"]`, we subtract it from queue time so slow request-body uploads are not counted as upstream queueing.
 
 We report the following metrics:
 
@@ -204,6 +212,44 @@ QueueLatency - Time job spent waiting in queue before execution (Seconds)
 
 This metric includes QueueName dimension and is aggregated per interval using CloudWatch StatisticSets.
 
+## Yabeda
+
+If you define application metrics with [Yabeda](https://github.com/yabeda-rb/yabeda), this gem can act as a Yabeda adapter and send those metrics through the same async `Reporter` pipeline used by the built-in integrations.
+
+This is optional. If you use it, you'll also want Yabeda metric collectors such as [yabeda-sidekiq](https://github.com/yabeda-rb/yabeda-sidekiq), [yabeda-puma-plugin](https://github.com/yabeda-rb/yabeda-puma-plugin), or [yabeda-rack-queue](https://github.com/speedshop/yabeda-rack-queue).
+
+```ruby
+# Gemfile
+gem 'speedshop-cloudwatch'
+gem 'yabeda'
+gem 'yabeda-sidekiq'
+```
+
+```ruby
+# config/initializers/yabeda.rb
+require 'speedshop/cloudwatch/yabeda'
+require 'yabeda/sidekiq'
+
+Yabeda.register_adapter(:cloudwatch, Speedshop::Cloudwatch::Yabeda.new)
+```
+
+If you're using collector-driven Yabeda integrations such as `yabeda-puma-plugin`, start the reporter in that process during boot so `Yabeda.collect!` has somewhere to run. For Puma, that usually means `config/puma.rb`:
+
+```ruby
+plugin :yabeda
+Speedshop::Cloudwatch.start!
+```
+
+Direct Yabeda `increment`, `set`, `measure`, and `observe` calls lazy-start the reporter on first use. Periodic Yabeda collectors only run inside that reporter thread.
+
+Behavior notes:
+
+- Group names become CloudWatch namespaces in [`namespace_for`](lib/speedshop/cloudwatch/yabeda.rb).
+- Yabeda tags become CloudWatch dimensions, and `config.dimensions` are appended in [`dimensions_for`](lib/speedshop/cloudwatch/yabeda.rb).
+- Known Yabeda units are mapped to CloudWatch units in [`UNIT_MAP`](lib/speedshop/cloudwatch/yabeda.rb); unknown units default to `"None"` in [`unit_for`](lib/speedshop/cloudwatch/yabeda.rb).
+- Direct Yabeda updates are enqueued by the adapter, and periodic Yabeda collectors are run by [`Yabeda::Collector`](lib/speedshop/cloudwatch/yabeda.rb) through the async [`Reporter`](lib/speedshop/cloudwatch/reporter.rb).
+- This adapter is opt-in and is **not** loaded by `require 'speedshop/cloudwatch/all'`.
+
 ## Rails
 
 When running in a Rails app we:

data/lib/speedshop/cloudwatch/active_job.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "speedshop/cloudwatch/observations"
+
 module Speedshop
   module Cloudwatch
     module ActiveJob
@@ -9,10 +11,14 @@ module Speedshop
 
       def report_job_metrics
         begin
-          if enqueued_at
-            queue_time = Time.now.to_f - enqueued_at.to_f
-            # Drop JobClass to reduce time series cardinality and allow aggregation into StatisticSets per queue
-            Reporter.instance.report(metric: :QueueLatency, value: queue_time, dimensions: {QueueName: queue_name}, integration: :active_job)
+          observation = Observations::ActiveJob.queue_latency(self)
+          if observation
+            MetricMapper.instance.report(
+              metric: :QueueLatency,
+              value: observation[:value],
+              dimensions: observation[:dimensions],
+              integration: :active_job
+            )
           end
         rescue => e
           Speedshop::Cloudwatch.log_error("Failed to collect ActiveJob metrics: #{e.message}", e)

data/lib/speedshop/cloudwatch/metric_mapper.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "singleton"
+require_relative "metrics"
+
+module Speedshop
+  module Cloudwatch
+    # Maps this gem's built-in metric families in METRICS to CloudWatch datums.
+    # The Yabeda adapter bypasses this class and builds datums directly because
+    # Yabeda metrics are dynamic and don't need to be present in METRICS.
+    class MetricMapper
+      include Singleton
+
+      def report(metric:, value: nil, statistic_values: nil, dimensions: {}, integration: nil)
+        return unless config.environment_enabled?
+
+        metric_name = metric.to_sym
+        resolved_integration = integration || find_integration_for_metric(metric_name)
+        return unless resolved_integration
+        return unless metric_allowed?(resolved_integration, metric_name)
+
+        Reporter.instance.enqueue(build_datum(
+          metric_name: metric_name,
+          integration: resolved_integration,
+          value: value,
+          statistic_values: statistic_values,
+          dimensions: dimensions
+        ))
+      end
+
+      private
+
+      def config
+        Config.instance
+      end
+
+      def build_datum(metric_name:, integration:, value:, statistic_values:, dimensions:)
+        metric_object = METRICS[integration]&.find { |metric| metric.name == metric_name }
+        datum = {
+          metric_name: metric_name.to_s,
+          namespace: config.namespaces[integration],
+          unit: metric_object&.unit || "None",
+          dimensions: metric_dimensions(dimensions),
+          timestamp: Time.now
+        }
+
+        if statistic_values
+          datum[:statistic_values] = statistic_values
+        else
+          datum[:value] = value
+        end
+
+        datum
+      end
+
+      def metric_dimensions(dimensions)
+        metric_dimensions = dimensions.map { |name, value| {name: name.to_s, value: value.to_s} }
+        metric_dimensions + custom_dimensions
+      end
+
+      def metric_allowed?(integration, metric_name)
+        config.metrics[integration].include?(metric_name.to_sym)
+      end
+
+      def custom_dimensions
+        config.dimensions.map { |name, value| {name: name.to_s, value: value.to_s} }
+      end
+
+      def find_integration_for_metric(metric_name)
+        METRICS.find { |integration, metrics| metrics.any? { |metric| metric.name == metric_name } }&.first
+      end
+    end
+  end
+end

data/lib/speedshop/cloudwatch/metrics.rb

@@ -162,7 +162,7 @@ module Speedshop
           description: "Time a request spent waiting in the reverse proxy before " \
                        "reaching the application. High values indicate requests " \
                        "backing up before reaching your application server.",
-          source: "(Time.now.to_f * 1000) - HTTP_X_REQUEST_START"
+          source: "parsed X-Request-Start/X-Queue-Start timestamp minus Puma request body wait"
         )
       ],
 

data/lib/speedshop/cloudwatch/observations/active_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Speedshop
+  module Cloudwatch
+    module Observations
+      module ActiveJob
+        module_function
+
+        def queue_latency(job, now: Time.now.to_f)
+          return unless job.enqueued_at
+
+          {
+            value: now - job.enqueued_at.to_f,
+            dimensions: {QueueName: job.queue_name}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/speedshop/cloudwatch/observations/puma.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Speedshop
+  module Cloudwatch
+    module Observations
+      module Puma
+        module_function
+
+        def from_stats(stats)
+          if stats[:worker_status]
+            clustered_observations(stats)
+          else
+            single_mode_observations(stats)
+          end
+        end
+
+        def clustered_observations(stats)
+          observations = %i[workers booted_workers old_workers].map do |metric|
+            {metric: metric_name_for(metric), value: stats[metric] || 0}
+          end
+
+          stats[:worker_status].each do |worker_status|
+            last_status = worker_status[:last_status] || {}
+            %i[running backlog pool_capacity max_threads].each do |metric|
+              next unless last_status.key?(metric)
+
+              observations << {metric: metric_name_for(metric), value: last_status[metric]}
+            end
+          end
+
+          observations
+        end
+
+        def single_mode_observations(stats)
+          %i[running backlog pool_capacity max_threads].map do |metric|
+            {metric: metric_name_for(metric), value: stats[metric] || 0}
+          end
+        end
+
+        def metric_name_for(symbol)
+          symbol.to_s.split("_").map(&:capitalize).join.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/speedshop/cloudwatch/observations/rack.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Speedshop
+  module Cloudwatch
+    module Observations
+      module Rack
+        class HeaderTimestampParser
+          MIN_EPOCH = Time.utc(2000, 1, 1).to_f
+          FUTURE_TOLERANCE = 30.0
+          DIVISORS = [1_000_000.0, 1_000.0, 1.0].freeze
+          NUMBER_RE = /[+-]?(?:\d+(?:\.\d+)?|\.\d+)/
+          T_EQUALS_RE = /t\s*=\s*(#{NUMBER_RE.source})/i
+
+          def parse(value, now:)
+            header_value = value.to_s.split(",", 2).first.to_s.strip
+            return if header_value.empty?
+
+            token = header_value[T_EQUALS_RE, 1] || header_value[NUMBER_RE, 0]
+            normalize(Float(token), now) if token
+          rescue ArgumentError, TypeError
+          end
+
+          private
+
+          def normalize(raw, now)
+            max = now + FUTURE_TOLERANCE
+            divisor = DIVISORS.find { |d| (raw / d).between?(MIN_EPOCH, max) }
+            raw / divisor if divisor
+          end
+        end
+
+        module_function
+
+        def request_queue_time(env, now_ms: current_time_ms)
+          now = now_ms / 1_000.0
+          request_start = header_timestamp_parser.parse(env["HTTP_X_REQUEST_START"], now: now) ||
+            header_timestamp_parser.parse(env["HTTP_X_QUEUE_START"], now: now)
+          return unless request_start
+
+          queue_time_ms = (now - request_start) * 1_000.0
+          return if queue_time_ms.negative?
+
+          [queue_time_ms - (request_body_wait_ms(env) || 0), 0.0].max
+        end
+
+        def current_time_ms
+          Time.now.to_f * 1_000.0
+        end
+
+        def header_timestamp_parser
+          @header_timestamp_parser ||= HeaderTimestampParser.new
+        end
+
+        def request_body_wait_ms(env)
+          wait_ms = Float(env["puma.request_body_wait"])
+          wait_ms if wait_ms.finite? && !wait_ms.negative?
+        rescue ArgumentError, TypeError
+        end
+      end
+    end
+  end
+end

data/lib/speedshop/cloudwatch/observations/sidekiq.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "sidekiq/api" if defined?(::Sidekiq)
+
+module Speedshop
+  module Cloudwatch
+    module Observations
+      module Sidekiq
+        module_function
+
+        def collect(sidekiq_queues: Config.instance.sidekiq_queues)
+          stats = ::Sidekiq::Stats.new
+          processes = ::Sidekiq::ProcessSet.new.to_a
+
+          stat_observations(stats) + utilization_observations(processes) + queue_observations(sidekiq_queues)
+        end
+
+        def stat_observations(stats)
+          {
+            EnqueuedJobs: stats.enqueued,
+            ProcessedJobs: stats.processed,
+            FailedJobs: stats.failed,
+            ScheduledJobs: stats.scheduled_size,
+            RetryJobs: stats.retry_size,
+            DeadJobs: stats.dead_size,
+            Workers: stats.workers_size,
+            Processes: stats.processes_size,
+            DefaultQueueLatency: stats.default_queue_latency
+          }.map do |metric, value|
+            {metric: metric, value: value}
+          end
+        end
+
+        def utilization_observations(processes)
+          observations = [{metric: :Capacity, value: processes.sum { |process| process["concurrency"] }}]
+
+          utilization = avg_utilization(processes) * 100.0
+          observations << {metric: :Utilization, value: utilization} unless utilization.nan?
+          observations
+        end
+
+        def queue_observations(sidekiq_queues)
+          queues_to_monitor(sidekiq_queues).flat_map do |queue|
+            [
+              {metric: :QueueLatency, value: queue.latency, dimensions: {QueueName: queue.name}},
+              {metric: :QueueSize, value: queue.size, dimensions: {QueueName: queue.name}}
+            ]
+          end
+        end
+
+        def queues_to_monitor(sidekiq_queues)
+          all_queues = ::Sidekiq::Queue.all
+          return all_queues if sidekiq_queues.nil? || sidekiq_queues.empty?
+
+          all_queues.select { |queue| sidekiq_queues.include?(queue.name) }
+        end
+
+        def avg_utilization(processes)
+          utils = processes.map { |process| process["busy"] / process["concurrency"].to_f }.reject(&:nan?)
+          utils.sum / utils.size.to_f
+        end
+      end
+    end
+  end
+end

data/lib/speedshop/cloudwatch/observations.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "speedshop/cloudwatch/observations/active_job"
+require "speedshop/cloudwatch/observations/puma"
+require "speedshop/cloudwatch/observations/rack"
+require "speedshop/cloudwatch/observations/sidekiq"

data/lib/speedshop/cloudwatch/puma.rb

@@ -1,56 +1,21 @@
 # frozen_string_literal: true
 
+require "speedshop/cloudwatch/observations"
+
 module Speedshop
   module Cloudwatch
     class Puma
       def collect
-        stats = ::Puma.stats_hash
-
-        if stats[:worker_status]
-          %i[workers booted_workers old_workers].each do |m|
-            Reporter.instance.report(metric: metric_name_for(m), value: stats[m] || 0)
-          end
-          report_aggregate_worker_stats(stats)
-        else
-          # Single mode - report worker stats without dimensions
-          %i[running backlog pool_capacity max_threads].each do |m|
-            Reporter.instance.report(metric: metric_name_for(m), value: stats[m] || 0)
-          end
-        end
-      rescue => e
-        Speedshop::Cloudwatch.log_error("Failed to collect Puma metrics: #{e.message}", e)
-      end
-
-      private
-
-      def report_aggregate_worker_stats(stats)
-        statuses = stats[:worker_status].map { |w| w[:last_status] || {} }
-        metrics = %i[running backlog pool_capacity max_threads]
-
-        metrics.each do |m|
-          values = statuses.map { |s| s[m] }.compact
-          next if values.empty?
-
-          sample_count = values.length
-          sum = values.inject(0) { |acc, v| acc + v.to_f }
-          minimum = values.min.to_f
-          maximum = values.max.to_f
-
-          Reporter.instance.report(
-            metric: metric_name_for(m),
-            statistic_values: {
-              sample_count: sample_count,
-              sum: sum,
-              minimum: minimum,
-              maximum: maximum
-            },
+        Observations::Puma.from_stats(::Puma.stats_hash).each do |observation|
+          MetricMapper.instance.report(
+            metric: observation[:metric],
+            value: observation[:value],
+            dimensions: observation[:dimensions] || {},
             integration: :puma
           )
         end
-      end
-
-      def metric_name_for(symbol)
-        symbol.to_s.split("_").map(&:capitalize).join.to_sym
+      rescue => e
+        Speedshop::Cloudwatch.log_error("Failed to collect Puma metrics: #{e.message}", e)
       end
     end
   end

data/lib/speedshop/cloudwatch/rack.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "speedshop/cloudwatch/observations"
+
 module Speedshop
   module Cloudwatch
     class Rack
@@ -9,10 +11,8 @@ module Speedshop
 
       def call(env)
         begin
-          if (header = env["HTTP_X_REQUEST_START"] || env["HTTP_X_QUEUE_START"])
-            queue_time = (Time.now.to_f * 1000) - header.gsub("t=", "").to_f
-            Reporter.instance.report(metric: :RequestQueueTime, value: queue_time)
-          end
+          queue_time = Observations::Rack.request_queue_time(env)
+          MetricMapper.instance.report(metric: :RequestQueueTime, value: queue_time) if queue_time
         rescue => e
           Speedshop::Cloudwatch.log_error("Failed to collect Rack metrics: #{e.message}", e)
         end

data/lib/speedshop/cloudwatch/reporter.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "singleton"
-require_relative "metrics"
 
 module Speedshop
   module Cloudwatch
@@ -26,11 +25,8 @@ module Speedshop
         @mutex.synchronize do
           return if started?
 
+          reset_after_fork! if forked?
           initialize_collectors
-          if forked?
-            @collectors.clear
-            @queue.clear
-          end
 
           Speedshop::Cloudwatch.log_info("Starting metric reporter (collectors: #{@collectors.map(&:class).join(", ")})")
           @running = true
@@ -68,30 +64,12 @@ module Speedshop
         end
       end
 
-      def report(metric:, value: nil, statistic_values: nil, dimensions: {}, integration: nil)
+      def enqueue(datum)
         return unless config.environment_enabled?
 
-        metric_name = metric.to_sym
-        int = integration || find_integration_for_metric(metric_name)
-        return unless int
-        return unless metric_allowed?(int, metric_name)
-
-        metric_object = METRICS[int]&.find { |m| m.name == metric_name }
-        ns = config.namespaces[int]
-        unit = metric_object&.unit || "None"
-
-        dimensions_array = dimensions.map { |k, v| {name: k.to_s, value: v.to_s} }
-        all_dimensions = dimensions_array + custom_dimensions
-
-        datum = {metric_name: metric_name.to_s, namespace: ns, unit: unit,
-                 dimensions: all_dimensions, timestamp: Time.now}
-        if statistic_values
-          datum[:statistic_values] = statistic_values
-        else
-          datum[:value] = value
-        end
-
         @mutex.synchronize do
+          reset_after_fork! if forked?
+
           if @queue.size >= config.queue_max_size
             @queue.shift
             @dropped_since_last_flush += 1
@@ -137,10 +115,20 @@ module Speedshop
         @pid != Process.pid
       end
 
+      def reset_after_fork!
+        @collectors.clear
+        @queue.clear
+        @thread = nil
+        @running = false
+        @dropped_since_last_flush = 0
+        @pid = Process.pid
+      end
+
       def initialize_collectors
         config.collectors.each do |integration|
           @collectors << Speedshop::Cloudwatch::Puma.new if integration == :puma
           @collectors << Speedshop::Cloudwatch::Sidekiq.new if integration == :sidekiq
+          @collectors << Speedshop::Cloudwatch::Yabeda::Collector.new if integration == :yabeda
         rescue => e
           Speedshop::Cloudwatch.log_error("Failed to initialize collector for #{integration}: #{e.message}", e)
         end
@@ -230,7 +218,7 @@ module Speedshop
       def group_metrics(ns_metrics)
         groups = {}
         ns_metrics.each do |m|
-          key = [m[:metric_name], m[:unit], normalized_dimensions_key(m[:dimensions])]
+          key = [m[:metric_name], m[:unit], normalized_dimensions_key(m[:dimensions]), m[:aggregation_strategy]]
           (groups[key] ||= []) << m
         end
         groups.values
@@ -239,6 +227,10 @@ module Speedshop
       def aggregate_group(items)
         return items.first if items.size == 1
 
+        strategy = items.first[:aggregation_strategy]
+        return aggregate_most_recent_group(items) if strategy == :most_recent
+        return aggregate_max_group(items) if strategy == :max
+
         sample_count, sum, minimum, maximum = aggregate_values(items)
         {
           metric_name: items.first[:metric_name],
@@ -275,6 +267,21 @@ module Speedshop
         [sample_count, sum, minimum, maximum]
       end
 
+      def aggregate_most_recent_group(items)
+        items.last
+      end
+
+      def aggregate_max_group(items)
+        items.max_by { |item| item_value_for_max(item) }
+      end
+
+      def item_value_for_max(item)
+        return item[:statistic_values][:maximum].to_f if item[:statistic_values]
+        return item[:value].to_f if item.key?(:value)
+
+        -Float::INFINITY
+      end
+
       def build_statistic_values(sample_count, sum, minimum, maximum)
         {
           sample_count: sample_count,
@@ -288,18 +295,6 @@ module Speedshop
         (dims || []).sort_by { |d| d[:name].to_s }.map { |d| "#{d[:name]}=#{d[:value]}" }.join("|")
       end
 
-      def metric_allowed?(integration, metric_name)
-        config.metrics[integration].include?(metric_name.to_sym)
-      end
-
-      def custom_dimensions
-        config.dimensions.map { |name, value| {name: name.to_s, value: value.to_s} }
-      end
-
-      def find_integration_for_metric(metric_name)
-        METRICS.find { |int, metrics| metrics.any? { |m| m.name == metric_name } }&.first
-      end
-
       def log_overflow_if_needed
         dropped = nil
         @mutex.synchronize do

data/lib/speedshop/cloudwatch/sidekiq.rb

@@ -24,18 +24,20 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require "sidekiq/api" if defined?(::Sidekiq)
+require "speedshop/cloudwatch/observations"
 
 module Speedshop
   module Cloudwatch
     class Sidekiq
       def collect
-        stats = ::Sidekiq::Stats.new
-        processes = ::Sidekiq::ProcessSet.new.to_a
-
-        report_stats(stats)
-        report_utilization(processes)
-        report_queue_metrics
+        Observations::Sidekiq.collect.each do |observation|
+          metric_mapper.report(
+            metric: observation[:metric],
+            value: observation[:value],
+            dimensions: observation[:dimensions] || {},
+            integration: :sidekiq
+          )
+        end
       rescue => e
         Speedshop::Cloudwatch.log_error("Failed to collect Sidekiq metrics: #{e.message}", e)
       end
@@ -68,48 +70,8 @@ module Speedshop
 
       private
 
-      def reporter
-        Speedshop::Cloudwatch.reporter
-      end
-
-      def report_stats(stats)
-        {
-          EnqueuedJobs: stats.enqueued, ProcessedJobs: stats.processed, FailedJobs: stats.failed,
-          ScheduledJobs: stats.scheduled_size, RetryJobs: stats.retry_size, DeadJobs: stats.dead_size,
-          Workers: stats.workers_size, Processes: stats.processes_size,
-          DefaultQueueLatency: stats.default_queue_latency
-        }.each { |m, v| reporter.report(metric: m, value: v, integration: :sidekiq) }
-      end
-
-      def report_utilization(processes)
-        capacity = processes.sum { |p| p["concurrency"] }
-        reporter.report(metric: :Capacity, value: capacity)
-
-        utilization = avg_utilization(processes) * 100.0
-        reporter.report(metric: :Utilization, value: utilization) unless utilization.nan?
-      end
-
-      def report_queue_metrics
-        queues_to_monitor.each do |q|
-          reporter.report(metric: :QueueLatency, value: q.latency, dimensions: {QueueName: q.name})
-          reporter.report(metric: :QueueSize, value: q.size, dimensions: {QueueName: q.name})
-        end
-      end
-
-      def queues_to_monitor
-        all_queues = ::Sidekiq::Queue.all
-        configured = Speedshop::Cloudwatch.config.sidekiq_queues
-
-        if configured.nil? || configured.empty?
-          all_queues
-        else
-          all_queues.select { |q| configured.include?(q.name) }
-        end
-      end
-
-      def avg_utilization(processes)
-        utils = processes.map { |p| p["busy"] / p["concurrency"].to_f }.reject(&:nan?)
-        utils.sum / utils.size.to_f
+      def metric_mapper
+        Speedshop::Cloudwatch.metric_mapper
       end
     end
   end

data/lib/speedshop/cloudwatch/version.rb

@@ -2,6 +2,6 @@
 
 module Speedshop
   module Cloudwatch
-    VERSION = "0.1.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/speedshop/cloudwatch/yabeda.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "speedshop/cloudwatch"
+
+begin
+  require "yabeda" unless defined?(::Yabeda)
+rescue LoadError => e
+  if e.path == "yabeda"
+    raise LoadError, "speedshop/cloudwatch/yabeda requires the `yabeda` gem. Add `gem \"yabeda\"` to your Gemfile."
+  end
+
+  raise
+end
+
+module Speedshop
+  module Cloudwatch
+    class Yabeda < ::Yabeda::BaseAdapter
+      UNIT_MAP = {
+        seconds: "Seconds",
+        milliseconds: "Milliseconds",
+        microseconds: "Microseconds",
+        bytes: "Bytes",
+        kilobytes: "Kilobytes",
+        megabytes: "Megabytes",
+        gigabytes: "Gigabytes",
+        terabytes: "Terabytes",
+        bits: "Bits",
+        kilobits: "Kilobits",
+        megabits: "Megabits",
+        gigabits: "Gigabits",
+        terabits: "Terabits",
+        percent: "Percent",
+        count: "Count"
+      }.freeze
+
+      def initialize(namespace_formatter: nil, metric_name_formatter: nil, dimension_name_formatter: nil, allowlist: nil)
+        @namespace_formatter = namespace_formatter
+        @metric_name_formatter = metric_name_formatter
+        @dimension_name_formatter = dimension_name_formatter
+        @allowlist = normalize_allowlist(allowlist)
+
+        Speedshop::Cloudwatch.configure do |config|
+          config.collectors << :yabeda unless config.collectors.include?(:yabeda)
+        end
+      end
+
+      # CloudWatch doesn't require pre-registration of metrics, but Yabeda's adapter
+      # interface expects these hooks to exist for backends that do.
+      def register_counter!(_metric)
+      end
+
+      def register_gauge!(_metric)
+      end
+
+      def register_histogram!(_metric)
+      end
+
+      def register_summary!(_metric)
+      end
+
+      def perform_counter_increment!(counter, tags, increment)
+        enqueue_metric(counter, tags, increment)
+      end
+
+      def perform_gauge_set!(gauge, tags, value)
+        enqueue_metric(gauge, tags, value)
+      end
+
+      def perform_histogram_measure!(histogram, tags, value)
+        enqueue_metric(histogram, tags, value)
+      end
+
+      def perform_summary_observe!(summary, tags, value)
+        enqueue_metric(summary, tags, value)
+      end
+
+      class Collector
+        def collect
+          ::Yabeda.collect!
+        end
+      end
+
+      private
+
+      def enqueue_metric(metric, tags, value)
+        namespace = namespace_for(metric)
+        metric_name = metric_name_for(metric)
+        return unless allowed?(namespace, metric_name)
+
+        Reporter.instance.enqueue(
+          metric_name: metric_name,
+          namespace: namespace,
+          unit: unit_for(metric),
+          dimensions: dimensions_for(tags),
+          value: value,
+          timestamp: Time.now,
+          aggregation_strategy: aggregation_strategy_for(metric)
+        )
+      end
+
+      def namespace_for(metric)
+        format_value(metric.group.to_s.split("_").map(&:capitalize).join, @namespace_formatter, metric)
+      end
+
+      def metric_name_for(metric)
+        format_value(metric.name.to_s, @metric_name_formatter, metric)
+      end
+
+      def unit_for(metric)
+        UNIT_MAP.fetch(metric.unit&.to_sym, "None")
+      end
+
+      def dimensions_for(tags)
+        tag_dimensions = tags.to_h.map do |name, value|
+          {name: format_value(name.to_s, @dimension_name_formatter), value: value.to_s}
+        end
+        tag_dimensions + Config.instance.dimensions.map do |name, value|
+          {name: format_value(name.to_s, @dimension_name_formatter), value: value.to_s}
+        end
+      end
+
+      def aggregation_strategy_for(metric)
+        return unless metric.is_a?(::Yabeda::Gauge)
+
+        strategy = metric.aggregation&.to_sym
+        strategy if %i[most_recent max].include?(strategy)
+      end
+
+      def allowed?(namespace, metric_name)
+        return true unless @allowlist
+
+        Array(@allowlist[namespace]).map(&:to_s).include?(metric_name.to_s)
+      end
+
+      def normalize_allowlist(allowlist)
+        return unless allowlist
+
+        allowlist.each_with_object({}) do |(namespace, metrics), normalized|
+          normalized[namespace.to_s] = Array(metrics).map(&:to_s)
+        end
+      end
+
+      def format_value(value, formatter, metric = nil)
+        return value unless formatter
+
+        (formatter.arity == 1) ? formatter.call(value) : formatter.call(value, metric)
+      end
+    end
+  end
+end

data/lib/speedshop/cloudwatch.rb

@@ -3,6 +3,7 @@
 require "aws-sdk-cloudwatch"
 require "speedshop/cloudwatch/config"
 require "speedshop/cloudwatch/reporter"
+require "speedshop/cloudwatch/metric_mapper"
 require "speedshop/cloudwatch/version"
 
 module Speedshop
@@ -23,6 +24,10 @@ module Speedshop
         Reporter.instance
       end
 
+      def metric_mapper
+        MetricMapper.instance
+      end
+
       def start!
         reporter.start!
       end

data/speedshop-cloudwatch.gemspec

@@ -21,10 +21,13 @@ Gem::Specification.new do |spec|
   spec.files = IO.popen(%w[git ls-files -z], chdir: __dir__, err: IO::NULL) do |ls|
     ls.readlines("\x0", chomp: true).select do |path|
       path.start_with?("lib/", "bin/", "docs/") ||
-        %w[README.md LICENSE.txt speedshop-cloudwatch.gemspec Rakefile].include?(path)
+        %w[README.md CHANGELOG.md LICENSE.txt speedshop-cloudwatch.gemspec Rakefile].include?(path)
     end
   end
   spec.require_paths = ["lib"]
 
   spec.add_dependency "aws-sdk-cloudwatch", ">= 1.81.0"
+
+  spec.add_development_dependency "csv"
+  spec.add_development_dependency "yabeda"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: speedshop-cloudwatch
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Nate Berkopec
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-17 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-cloudwatch
@@ -24,6 +23,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.81.0
+- !ruby/object:Gem::Dependency
+  name: csv
+  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: yabeda
+  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'
 description: This gem helps integrate your Ruby application with AWS CloudWatch, reporting
   metrics from Puma, Rack, Sidekiq, and ActiveJob in background threads to avoid adding
   latency to requests and jobs.
@@ -33,6 +60,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGELOG.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -43,13 +71,20 @@ files:
 - lib/speedshop/cloudwatch/active_job.rb
 - lib/speedshop/cloudwatch/all.rb
 - lib/speedshop/cloudwatch/config.rb
+- lib/speedshop/cloudwatch/metric_mapper.rb
 - lib/speedshop/cloudwatch/metrics.rb
+- lib/speedshop/cloudwatch/observations.rb
+- lib/speedshop/cloudwatch/observations/active_job.rb
+- lib/speedshop/cloudwatch/observations/puma.rb
+- lib/speedshop/cloudwatch/observations/rack.rb
+- lib/speedshop/cloudwatch/observations/sidekiq.rb
 - lib/speedshop/cloudwatch/puma.rb
 - lib/speedshop/cloudwatch/rack.rb
 - lib/speedshop/cloudwatch/railtie.rb
 - lib/speedshop/cloudwatch/reporter.rb
 - lib/speedshop/cloudwatch/sidekiq.rb
 - lib/speedshop/cloudwatch/version.rb
+- lib/speedshop/cloudwatch/yabeda.rb
 - speedshop-cloudwatch.gemspec
 homepage: https://github.com/nateberkopec/speedshop-cloudwatch
 licenses:
@@ -58,7 +93,6 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/nateberkopec/speedshop-cloudwatch
   source_code_uri: https://github.com/nateberkopec/speedshop-cloudwatch
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -73,8 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Ruby application integration with AWS CloudWatch for Puma, Rack, Sidekiq,
   and ActiveJob