naijacloud-argus 0.1.0

data/lib/naijacloud/argus/configuration.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module NaijaCloud
+  module Argus
+    # Options for `NaijaCloud::Argus.init`. Every option can be passed as a
+    # keyword or set in the block:
+    #
+    #   NaijaCloud::Argus.init(dsn: "...", release: "1.4.2")
+    #   NaijaCloud::Argus.init { |c| c.traces_sample_rate = 0.2 }
+    class Configuration
+      # Exceptions that describe a client's mistake rather than a bug. Matched
+      # by name so the gem does not have to load Rails to know them.
+      DEFAULT_EXCLUDED = %w[
+        ActionController::RoutingError
+        ActionController::UnknownFormat
+        ActionController::BadRequest
+        ActionController::ParameterMissing
+        ActionController::InvalidAuthenticityToken
+        ActionDispatch::Http::MimeNegotiation::InvalidType
+        ActiveRecord::RecordNotFound
+        AbstractController::ActionNotFound
+        Sinatra::NotFound
+      ].freeze
+
+      OPTIONS = %i[
+        dsn release environment service_name server_name sample_rate
+        traces_sample_rate send_default_pii max_breadcrumbs before_send
+        before_breadcrumb debug enabled project_root context_lines
+        excluded_exceptions trace_propagation net_http rails_logs
+        capture_at_exit debug_output
+      ].freeze
+
+      attr_accessor(*OPTIONS)
+
+      def initialize(**options)
+        @dsn = nil
+        @release = nil
+        @environment = nil
+        @service_name = nil
+        @server_name = nil
+        @sample_rate = 1.0
+        @traces_sample_rate = 1.0
+        @send_default_pii = false
+        @max_breadcrumbs = 100
+        @before_send = nil
+        @before_breadcrumb = nil
+        @debug = false
+        @enabled = true
+        @project_root = nil
+        @context_lines = true
+        @excluded_exceptions = DEFAULT_EXCLUDED.dup
+        @trace_propagation = true
+        @net_http = true
+        @rails_logs = false
+        @capture_at_exit = true
+        @debug_output = $stderr
+        options.each do |key, value|
+          # A typo in an option must not stop the app booting; say so instead.
+          unless OPTIONS.include?(key.to_sym)
+            warn("[argus] unknown option #{key.inspect} ignored")
+            next
+          end
+
+          public_send("#{key}=", value)
+        end
+      end
+
+      # Spec §1: the explicit option wins, then ARGUS_*, then SENTRY_*.
+      def resolve!(env = ENV)
+        @dsn = first(@dsn, env["ARGUS_DSN"], env["SENTRY_DSN"])
+        @release = first(@release, env["ARGUS_RELEASE"], env["SENTRY_RELEASE"])
+        @environment = first(@environment, env["ARGUS_ENVIRONMENT"], env["SENTRY_ENVIRONMENT"], "production")
+        @service_name = first(@service_name, env["ARGUS_SERVICE_NAME"], env["OTEL_SERVICE_NAME"], "app")
+        @debug ||= %w[1 true yes].include?(env["ARGUS_DEBUG"].to_s.downcase)
+        self
+      end
+
+      def inspect
+        "#<NaijaCloud::Argus::Configuration environment=#{@environment.inspect} release=#{@release.inspect}>"
+      end
+
+      private
+
+      def first(*values)
+        values.each do |v|
+          next if v.nil?
+
+          s = v.to_s.strip
+          return s unless s.empty?
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/naijacloud/argus/dsn.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module NaijaCloud
+  module Argus
+    # A parsed DSN: `https://<public_key>@<host>/<project_id>` (spec §1).
+    class Dsn
+      attr_reader :public_key, :project_id, :origin, :raw
+
+      # Returns a Dsn, or nil for anything that is not one. Never raises: a
+      # typo in an environment variable must not take the app down at boot.
+      def self.parse(raw)
+        return nil unless raw.is_a?(String)
+
+        raw = raw.strip
+        return nil if raw.empty?
+
+        uri = URI.parse(raw)
+        return nil unless %w[http https].include?(uri.scheme)
+        return nil if uri.host.nil? || uri.host.empty?
+
+        key = uri.user && URI.decode_www_form_component(uri.user)
+        parts = uri.path.to_s.split("/").reject(&:empty?)
+        project = parts.pop
+        return nil if key.nil? || key.empty? || project.nil? || project !~ /\A\d+\z/
+
+        prefix = parts.empty? ? "" : "/#{parts.join('/')}"
+        port = uri.port == uri.default_port ? "" : ":#{uri.port}"
+        new(public_key: key, project_id: project, origin: "#{uri.scheme}://#{uri.host}#{port}#{prefix}", raw: raw)
+      rescue URI::Error, ArgumentError
+        nil
+      end
+
+      def initialize(public_key:, project_id:, origin:, raw:)
+        @public_key = public_key
+        @project_id = project_id
+        @origin = origin
+        @raw = raw
+      end
+
+      # The error endpoint (spec §3). Servers authenticate with a header, so
+      # the key stays out of the URL and out of any proxy's access log.
+      def envelope_url
+        "#{origin}/api/#{project_id}/envelope/"
+      end
+
+      def ingest_url(path)
+        "#{origin}#{path}"
+      end
+
+      # The key is public by design, but a DSN dumped by an error reporter is
+      # still noise nobody needs; show which source it is, not the key.
+      def inspect
+        "#<NaijaCloud::Argus::Dsn #{origin}/#{project_id}>"
+      end
+      alias to_s inspect
+    end
+  end
+end

data/lib/naijacloud/argus/integrations/net_http.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module NaijaCloud
+  module Argus
+    module Integrations
+      # Outgoing Net::HTTP requests (and every client built on it: Faraday's
+      # default adapter, HTTParty, RestClient, ActiveResource): a breadcrumb
+      # each, and inside a span a child client span plus a W3C `traceparent`
+      # header so the service called continues the trace (spec §5).
+      module NetHTTP
+        @installed = false
+
+        def self.install
+          return if @installed
+
+          @installed = true
+          ::Net::HTTP.prepend(Patch)
+        end
+
+        module Patch
+          def request(req, body = nil, &block)
+            # Net::HTTP#request calls itself again from inside `start` when
+            # the connection was not open yet; trace the inner call only.
+            return super unless started?
+            return super if Transport.internal?
+
+            client = Argus.client
+            return super unless client&.enabled?
+
+            Argus::Integrations::NetHTTP.traced(client, self, req) { super }
+          end
+        end
+
+        def self.traced(client, http, req)
+          method = req.method.to_s
+          port = http.port == (http.use_ssl? ? 443 : 80) ? "" : ":#{http.port}"
+          url = "#{http.use_ssl? ? 'https' : 'http'}://#{http.address}#{port}#{Scrub.strip_query(req.path)}"
+          span = nil
+          if Span.current
+            span = client.start_span("#{method} #{url}", kind: Span::KIND_CLIENT,
+                                                          attributes: { "http.request.method" => method, "url.full" => url,
+                                                                        "server.address" => http.address })
+            req["traceparent"] = span.traceparent if client.config.trace_propagation && req["traceparent"].nil?
+          end
+
+          begin
+            res = yield
+          rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised
+            span&.finish(e)
+            crumb(client, method, url, nil, "error")
+            raise
+          end
+
+          code = res.code.to_i
+          if span
+            span.set_attribute("http.response.status_code", code)
+            span.finish(code >= 500 ? "HTTP #{code}" : nil)
+          end
+          crumb(client, method, url, code, code >= 500 ? "error" : nil)
+          res
+        end
+
+        def self.crumb(client, method, url, status, level)
+          data = { method: method, url: url }
+          data[:status_code] = status if status
+          c = { type: "http", category: "net.http", data: data }
+          c[:level] = level if level
+          client.add_breadcrumb(c)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/naijacloud/argus/integrations/rack.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module NaijaCloud
+  module Argus
+    # Rack middleware: a server span per request (continuing the caller's W3C
+    # `traceparent`), named by the route once the router has matched it, and
+    # unhandled exceptions reported with the request they came from.
+    #
+    #   use NaijaCloud::Argus::Rack            # config.ru, Sinatra, Hanami, Roda
+    #
+    # Rails does not need this line: the Railtie inserts it.
+    class Rack
+      # Headers worth seeing on an error. An allowlist, not a denylist: a
+      # header nobody thought of is not sent. Cookie is never sent (spec §7).
+      HEADERS = %w[
+        HTTP_HOST HTTP_USER_AGENT HTTP_ACCEPT HTTP_ACCEPT_LANGUAGE HTTP_REFERER
+        HTTP_X_REQUEST_ID HTTP_X_FORWARDED_PROTO HTTP_X_FORWARDED_HOST HTTP_TRACEPARENT
+        CONTENT_TYPE CONTENT_LENGTH
+      ].freeze
+
+      # Where frameworks leave an exception they rendered as an error page
+      # instead of letting it raise through us.
+      EXCEPTION_KEYS = %w[action_dispatch.exception rack.exception sinatra.error].freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        client = Argus.client
+        return @app.call(env) unless client&.enabled? && !env["naijacloud.argus.span"]
+
+        client.with_scope { |scope| call_with(client, scope, env) }
+      end
+
+      # The route template for a request, once routing has happened:
+      # "/users/:id", or nil when the framework does not say.
+      def self.route(env)
+        if (pattern = env["action_dispatch.route_uri_pattern"])
+          return pattern.to_s.sub(/\(\.:format\)\z/, "")
+        end
+        if (sinatra = env["sinatra.route"])
+          return sinatra.to_s.split(" ", 2).last
+        end
+        if (grape = env["grape.routing_args"]) && grape.is_a?(Hash) && (info = grape[:route_info])
+          return info.path.to_s.sub(/\(\.:format\)\z/, "") if info.respond_to?(:path)
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
+      # "UsersController#show" for Rails before 7.1, where the URI pattern is
+      # not in the env.
+      def self.controller_action(env)
+        params = env["action_dispatch.request.path_parameters"]
+        return nil unless params.is_a?(Hash) && params[:controller] && params[:action]
+
+        "#{params[:controller]}##{params[:action]}"
+      end
+
+      def self.url(env)
+        scheme = env["HTTP_X_FORWARDED_PROTO"].to_s.split(",").first || env["rack.url_scheme"] || "http"
+        host = env["HTTP_HOST"] || "#{env['SERVER_NAME']}:#{env['SERVER_PORT']}"
+        "#{scheme.strip}://#{host}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+      end
+
+      private
+
+      def call_with(client, scope, env)
+        method = env["REQUEST_METHOD"].to_s
+        path = "#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+        url = Scrub.strip_query(Rack.url(env))
+        span = client.start_span(
+          "#{method} #{path}",
+          kind: Span::KIND_SERVER,
+          parent: Span.parse_traceparent(env["HTTP_TRACEPARENT"]),
+          attributes: { "http.request.method" => method, "url.full" => url, "url.path" => path,
+                        "server.address" => env["HTTP_HOST"] || env["SERVER_NAME"] },
+        )
+        env["naijacloud.argus.span"] = span
+        scope.request = request_info(client, env, method, url)
+        scope.transaction = -> { name_for(env, method) }
+
+        begin
+          status, headers, body = Span.with(span) { @app.call(env) }
+        rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised
+          finish(span, env, method, 500)
+          unless e.is_a?(SignalException) || e.is_a?(SystemExit)
+            client.capture_exception(e, tags: { mechanism: "rack" }, transaction: name_for(env, method))
+          end
+          raise
+        end
+
+        status = status.to_i
+        if status >= 500 && (err = EXCEPTION_KEYS.lazy.map { |k| env[k] }.find { |x| x.is_a?(Exception) })
+          client.capture_exception(err, tags: { mechanism: "rack" }, transaction: name_for(env, method))
+        end
+        finish(span, env, method, status)
+        [status, headers, body]
+      end
+
+      def finish(span, env, method, status)
+        route = Rack.route(env)
+        span.set_attribute("http.route", route) if route
+        span.name = name_for(env, method)
+        span.set_attribute("http.response.status_code", status)
+        span.finish(status >= 500 ? "HTTP #{status}" : nil)
+      rescue StandardError
+        nil
+      end
+
+      def name_for(env, method)
+        route = Rack.route(env)
+        return "#{method} #{route}" if route
+
+        Rack.controller_action(env) || "#{method} #{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+      end
+
+      def request_info(client, env, method, url)
+        headers = {}
+        HEADERS.each do |key|
+          next unless env[key]
+
+          name = key.sub(/\AHTTP_/, "").split("_").map(&:capitalize).join("-")
+          headers[name] = env[key].to_s
+        end
+        info = { method: method, url: url, headers: headers }
+        info[:env] = { "REMOTE_ADDR" => env["REMOTE_ADDR"] } if client.config.send_default_pii && env["REMOTE_ADDR"]
+        info
+      end
+    end
+  end
+end

data/lib/naijacloud/argus/integrations/rails.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module NaijaCloud
+  module Argus
+    module Integrations
+      # Reports errors from Rails' error reporter (Rails 7.0+): unhandled
+      # request and job errors, and anything an app passes to
+      # `Rails.error.report` / `Rails.error.handle`.
+      class ErrorSubscriber
+        def report(error, handled:, severity: :error, context: {}, source: nil)
+          client = Argus.client
+          return unless client&.enabled?
+
+          tags = { "handled" => handled.to_s, "mechanism" => "rails.error" }
+          tags["source"] = source.to_s if source
+          client.capture_exception(error, level: severity, tags: tags, extra: context.is_a?(Hash) ? context : nil)
+        rescue StandardError
+          nil
+        end
+      end
+
+      # ActiveJob: each perform gets its own scope and span, and a failure is
+      # reported with the job's class, id and queue. The exception is
+      # re-raised, so retry_on / discard_on behave as before.
+      module ActiveJob
+        def self.included(base)
+          base.around_perform do |job, block|
+            NaijaCloud::Argus::Integrations::ActiveJob.around(job) { block.call }
+          end
+        end
+
+        def self.around(job)
+          client = Argus.client
+          return yield unless client&.enabled?
+
+          name = job.class.name.to_s
+          client.with_scope do |scope|
+            scope.transaction = name
+            scope.set_tag("job.queue", job.queue_name) if job.respond_to?(:queue_name)
+            scope.set_context("job", {
+              class: name,
+              job_id: job.job_id,
+              queue: (job.queue_name if job.respond_to?(:queue_name)),
+              executions: (job.executions if job.respond_to?(:executions)),
+              provider_job_id: (job.provider_job_id if job.respond_to?(:provider_job_id)),
+            })
+            attrs = { "messaging.system" => "active_job", "job.id" => job.job_id }
+            attrs["messaging.destination.name"] = job.queue_name if job.respond_to?(:queue_name)
+            begin
+              client.trace(name, attrs) { yield }
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised
+              client.capture_exception(e, tags: { mechanism: "active_job" }) unless e.is_a?(SignalException)
+              raise
+            end
+          end
+        end
+      end
+
+      module RailsSetup
+        module_function
+
+        # Called after the app's own initializers, so an explicit
+        # `NaijaCloud::Argus.init` in config/initializers wins.
+        def start(app)
+          unless Argus.initialized?
+            options = { project_root: ::Rails.root.to_s }
+            # Spec §1 defaults the environment to "production". A Rails app
+            # knows better than that when nothing was set.
+            if blank?(ENV["ARGUS_ENVIRONMENT"]) && blank?(ENV["SENTRY_ENVIRONMENT"])
+              options[:environment] = ::Rails.env.to_s
+            end
+            if blank?(ENV["ARGUS_SERVICE_NAME"]) && blank?(ENV["OTEL_SERVICE_NAME"])
+              options[:service_name] = app_name(app)
+            end
+            Argus.init(**options)
+          end
+          attach_logs if Argus.client&.config&.rails_logs && Argus.enabled?
+        rescue StandardError => e
+          warn("[argus] Rails setup failed: #{e.class}: #{e.message}")
+        end
+
+        def attach_logs
+          sink = Argus::Logger.new(level: ::Rails.logger.level)
+          if ::Rails.logger.respond_to?(:broadcast_to)
+            ::Rails.logger.broadcast_to(sink)
+          elsif defined?(::ActiveSupport::Logger) && ::ActiveSupport::Logger.respond_to?(:broadcast)
+            ::Rails.logger.extend(::ActiveSupport::Logger.broadcast(sink))
+          end
+        end
+
+        # `Shop::Application` -> "shop"; a top-level `ShopApp` -> "shop_app".
+        def app_name(app)
+          klass = app.class
+          parent = klass.module_parent_name if klass.respond_to?(:module_parent_name)
+          parent ||= klass.name.to_s.split("::").first.to_s.sub(/Application\z/, "")
+          name = parent.to_s.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+          name.empty? ? nil : name
+        rescue StandardError
+          nil
+        end
+
+        def blank?(value)
+          value.nil? || value.strip.empty?
+        end
+      end
+    end
+
+    # `bundle add naijacloud-argus` plus `ARGUS_DSN` is the whole Rails setup.
+    class Railtie < ::Rails::Railtie
+      initializer "naijacloud_argus.middleware" do |app|
+        # First in the stack, so the request span covers every other
+        # middleware and the scope is open before anything can fail.
+        app.config.middleware.insert(0, NaijaCloud::Argus::Rack)
+      end
+
+      initializer "naijacloud_argus.active_job" do
+        ActiveSupport.on_load(:active_job) { include NaijaCloud::Argus::Integrations::ActiveJob }
+      end
+
+      initializer "naijacloud_argus.error_subscriber" do
+        if ::Rails.respond_to?(:error) && ::Rails.error.respond_to?(:subscribe)
+          ::Rails.error.subscribe(NaijaCloud::Argus::Integrations::ErrorSubscriber.new)
+        end
+      end
+
+      config.after_initialize do |app|
+        NaijaCloud::Argus::Integrations::RailsSetup.start(app)
+      end
+    end
+  end
+end

data/lib/naijacloud/argus/logger.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module NaijaCloud
+  module Argus
+    # A ::Logger that sends each line to Argus Logs instead of writing it
+    # anywhere. Use it as a broadcast target next to your existing logger:
+    #
+    #   Rails.logger.broadcast_to(NaijaCloud::Argus::Logger.new(level: :info))   # Rails 7.1+
+    #   logger = NaijaCloud::Argus::Logger.new                                     # plain Ruby
+    #
+    # or set `rails_logs = true` and the Railtie attaches one for you. A line
+    # written inside a request carries that request's trace id.
+    class Logger < ::Logger
+      SEVERITIES = {
+        ::Logger::DEBUG => :debug, ::Logger::INFO => :info, ::Logger::WARN => :warn,
+        ::Logger::ERROR => :error, ::Logger::FATAL => :fatal, ::Logger::UNKNOWN => :fatal
+      }.freeze
+      ANSI = /\e\[[0-9;]*m/.freeze
+
+      def initialize(level: ::Logger::DEBUG, progname: nil)
+        super(nil, level: level, progname: progname)
+      end
+
+      def add(severity, message = nil, progname = nil)
+        severity ||= ::Logger::UNKNOWN
+        return true if severity < level || Transport.internal?
+
+        if message.nil?
+          if block_given?
+            message = yield
+          else
+            message = progname
+            progname = @progname
+          end
+        end
+        text = case message
+               when ::String then message
+               when ::Exception then "#{message.class}: #{message.message}"
+               else message.inspect
+               end
+        text = text.gsub(ANSI, "").strip
+        return true if text.empty?
+
+        attrs = progname ? { "logger.name" => progname.to_s } : nil
+        Argus.safely { Argus.client&.log(SEVERITIES.fetch(severity, :info), text, attrs) }
+        true
+      end
+      alias log add
+
+      # Nothing to write to, so nothing to reopen or close.
+      def reopen(_logdev = nil)
+        self
+      end
+
+      def close; end
+    end
+  end
+end

data/lib/naijacloud/argus/otlp.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module NaijaCloud
+  module Argus
+    # OTLP/HTTP JSON builders (spec §5): only the fields Argus reads. JSON, not
+    # protobuf, so the gem needs no protobuf dependency.
+    module OTLP
+      SEVERITY = { trace: 1, debug: 5, info: 9, warn: 13, error: 17, fatal: 21 }.freeze
+      SCOPE = { name: "argus" }.freeze
+
+      module_function
+
+      def attrs(hash)
+        return [] if hash.nil?
+
+        hash.each_with_object([]) do |(key, v), out|
+          next if v.nil?
+
+          value = case v
+                  when true, false then { boolValue: v }
+                  when Integer then { intValue: v.to_s }
+                  when Float then v.finite? ? { doubleValue: v } : { stringValue: v.to_s }
+                  else { stringValue: v.to_s }
+                  end
+          out << { key: key.to_s, value: value }
+        end
+      end
+
+      # Unix nanoseconds as a string: JSON numbers lose precision past 2**53.
+      def nanos(time_s)
+        (time_s * 1_000_000_000).round.to_s
+      end
+
+      def logs(resource, records)
+        {
+          resourceLogs: [{
+            resource: { attributes: attrs(resource) },
+            scopeLogs: [{
+              scope: SCOPE,
+              logRecords: records.map do |r|
+                rec = {
+                  timeUnixNano: nanos(r[:time]),
+                  severityNumber: SEVERITY.fetch(r[:severity]),
+                  severityText: r[:severity].to_s.upcase,
+                  body: { stringValue: r[:body] },
+                  attributes: attrs(r[:attributes]),
+                }
+                rec[:traceId] = r[:trace_id] if r[:trace_id]
+                rec[:spanId] = r[:span_id] if r[:span_id]
+                rec
+              end,
+            }],
+          }],
+        }
+      end
+
+      def traces(resource, spans)
+        {
+          resourceSpans: [{
+            resource: { attributes: attrs(resource) },
+            scopeSpans: [{
+              scope: SCOPE,
+              spans: spans.map do |s|
+                span = { traceId: s[:trace_id], spanId: s[:span_id] }
+                span[:parentSpanId] = s[:parent_span_id] if s[:parent_span_id]
+                span.merge(
+                  name: s[:name],
+                  kind: s[:kind],
+                  startTimeUnixNano: nanos(s[:start]),
+                  endTimeUnixNano: nanos(s[:end]),
+                  attributes: attrs(s[:attributes]),
+                  status: s[:error] ? { code: 2, message: s[:error] } : { code: 1 },
+                )
+              end,
+            }],
+          }],
+        }
+      end
+
+      def metrics(resource, points)
+        metrics = points.map do |p|
+          base = { name: p[:name] }
+          base[:unit] = p[:unit] if p[:unit]
+          attributes = attrs(p[:attributes])
+          case p[:kind]
+          when :sum
+            base.merge(sum: {
+              aggregationTemporality: 1, # delta (spec §5)
+              isMonotonic: true,
+              dataPoints: [{ attributes: attributes, startTimeUnixNano: nanos(p[:start]),
+                             timeUnixNano: nanos(p[:end]), asDouble: p[:value].to_f }],
+            })
+          when :gauge
+            base.merge(gauge: { dataPoints: [{ attributes: attributes, timeUnixNano: nanos(p[:end]), asDouble: p[:value].to_f }] })
+          else
+            base.merge(histogram: {
+              aggregationTemporality: 1,
+              dataPoints: [{
+                attributes: attributes,
+                startTimeUnixNano: nanos(p[:start]),
+                timeUnixNano: nanos(p[:end]),
+                count: p[:count].to_s,
+                sum: p[:sum].to_f,
+                min: p[:min].to_f,
+                max: p[:max].to_f,
+                explicitBounds: p[:bounds],
+                bucketCounts: p[:buckets].map(&:to_s),
+              }],
+            })
+          end
+        end
+        { resourceMetrics: [{ resource: { attributes: attrs(resource) }, scopeMetrics: [{ scope: SCOPE, metrics: metrics }] }] }
+      end
+    end
+  end
+end