packrat-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66ef80151ead412a9237f8e93fc4d916ba4041b43518e4d7b25c9470ace3d90b
+  data.tar.gz: 26eb535015852176b0aa847ae220a0204b83f0bf6d201723f7cf2284b5ecd4ff
+SHA512:
+  metadata.gz: b9e188a68993bca9520e3300c20cc30ac19a122a19f369373aa20c278d07db7a740faceef69397cf34a17f9782628b2d29124b794f4d8c6ed6f8e0f06fa89911
+  data.tar.gz: ccf0946cbdd06bc2b30ee3ce01b234040853948cbdcab1d0578337165cb27114b30861a9b7035dc09a7022b920482fea7b7f8e4a92904730dff3c01888a9ccf5

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Packrat Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+# packrat-rails
+
+**To turn it off, set `PACKRAT_DISABLED=1`.** The app then boots as if the gem were not installed.
+
+OpenTelemetry for Rails, configured to send traces, logs and exceptions to
+[Packrat](https://packrat.sh) with one key.
+
+```sh
+bundle add packrat-rails
+bin/rails generate packrat --ingest-key=packrat_ingest_…
+bin/rails server
+```
+
+The generator creates `config/initializers/packrat.rb` with the ingest key from your Packrat setup
+page:
+
+```ruby
+Packrat.configure do |config|
+  config.ingest_key = ENV.fetch("PACKRAT_INGEST_KEY", "packrat_ingest_…")
+end
+```
+
+An ingest key can only send data, so you can commit the file. To keep the key out of the repository,
+run the generator without `--ingest-key` and set `PACKRAT_INGEST_KEY` where the app runs.
+
+The generator also turns on the [Packrat plugin for Claude Code](https://packrat.sh/docs/claude-code-plugin)
+in `.claude/settings.json`. Commit the file, and everyone who opens Claude Code in the repository and
+trusts the folder gets the plugin. If the file exists, the generator adds the plugin and keeps the rest.
+To leave the file alone, pass `--no-claude-code`.
+
+On boot the gem writes one line to the Rails log. It names the service and environment the app
+reports under:
+
+```
+Packrat: sending traces and logs for shop/production to https://ingest.packrat.sh (rack, action_pack, active_job, active_record, net_http, pg, logger)
+```
+
+## Configuration
+
+The ingest key and the ingest URL are the only settings in `Packrat.configure`. Everything else is an environment
+variable.
+
+| Variable                        | Default                     | Note                                                         |
+| ------------------------------- | --------------------------- | ------------------------------------------------------------ |
+| `PACKRAT_INGEST_KEY`            | `config.ingest_key`         | Wins over the initializer. With neither, the gem sends nothing and says so |
+| `PACKRAT_INGEST_URL`            | `config.ingest_url`, else `https://ingest.packrat.sh` | A local Packrat is `http://localhost:3100`. `--ingest-url` on the generator writes `config.ingest_url` |
+| `PACKRAT_DISABLED`              | unset                       | `1` turns the gem off in any environment                     |
+| `PACKRAT_OTEL_INSTRUMENTATIONS` | the list below              | Comma-separated names to add; a leading `-` removes one      |
+
+The instrumentations are `rack`, `action_pack`, `action_view`, `active_job`, `active_record`,
+`net_http`, `pg`, `mysql2`, `sidekiq`, `redis`, `aws_sdk`, `concurrent_ruby`, `rake` and `logger`. One for a library that is not in the app installs nothing.
+`PACKRAT_OTEL_INSTRUMENTATIONS=faraday,-action_view` adds Faraday (with
+`opentelemetry-instrumentation-faraday` in the Gemfile) and removes Action View. `action_mailer` and
+`active_storage` cannot be added: they must load before boot ends.
+
+The service name is `OTEL_SERVICE_NAME`, else `service.name` in `OTEL_RESOURCE_ATTRIBUTES`, else the
+app's module name (`Shop::Application` is `shop`). The environment is `Rails.env` unless
+`OTEL_RESOURCE_ATTRIBUTES` names one. The version is `BUILD_COMMIT`, `HEROKU_SLUG_COMMIT` or
+`SOURCE_VERSION`. The instance is `DYNO`, else the host name. A standard `OTEL_*` variable that is set always wins.
+
+The gem does nothing in the test environment.
+
+## Beside other tools
+
+- **Nothing else:** the gem configures OpenTelemetry.
+- **Your own OpenTelemetry setup:** the gem leaves it as it is and adds a second exporter, to Packrat.
+  If your exporter already sends to Packrat, it adds nothing.
+- **Sentry:** both run. The gem does not touch Sentry.
+- **Datadog's tracer:** the gem does nothing. Dual-ship from the Datadog Agent instead:
+  https://packrat.sh/docs/datadog

data/lib/generators/packrat/packrat_generator.rb

@@ -0,0 +1,62 @@
+require "json"
+require "rails/generators"
+
+module Packrat
+  module Generators
+    # bin/rails generate packrat --ingest-key=packrat_ingest_...
+    class PackratGenerator < Rails::Generators::Base
+      namespace "packrat"
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates config/initializers/packrat.rb, which gives the packrat-rails gem your ingest key, " \
+           "and turns on the Packrat plugin for Claude Code in .claude/settings.json."
+      class_option :ingest_key, type: :string, desc: "The ingest key from your Packrat setup page"
+      class_option :ingest_url, type: :string, desc: "Where to send, when it isn't https://ingest.packrat.sh"
+      class_option :claude_code, type: :boolean, default: true,
+                                 desc: "Turn on the Packrat plugin for Claude Code in .claude/settings.json"
+
+      CLAUDE_SETTINGS = ".claude/settings.json"
+      MARKETPLACE = { "source" => { "source" => "github", "repo" => "packratlabs/claude-plugin" } }.freeze
+      PLUGIN = "packrat@packrat"
+
+      def create_initializer
+        template "initializer.rb.tt", "config/initializers/packrat.rb"
+      end
+
+      # Everyone who opens Claude Code in the repository and trusts the folder gets the plugin. Other
+      # settings in the file are kept, and so is a plugin someone turned off on purpose.
+      def enable_claude_code_plugin
+        return unless options[:claude_code]
+
+        path = File.join(destination_root, CLAUDE_SETTINGS)
+        return create_file(CLAUDE_SETTINGS, settings_json({})) unless File.exist?(path)
+
+        current = JSON.parse(File.read(path))
+        merged = settings_json(current)
+        return say_status(:identical, CLAUDE_SETTINGS, :blue) if merged == File.read(path)
+
+        File.write(path, merged)
+        say_status :update, CLAUDE_SETTINGS
+      rescue JSON::ParserError
+        say_status :skip, "#{CLAUDE_SETTINGS} isn't valid JSON; add the Packrat plugin to it yourself", :yellow
+      end
+
+      private
+
+      def ingest_key
+        options[:ingest_key].to_s.strip
+      end
+
+      def ingest_url
+        options[:ingest_url].to_s.strip
+      end
+
+      def settings_json(settings)
+        settings = settings.dup
+        settings["extraKnownMarketplaces"] = { "packrat" => MARKETPLACE }.merge(settings["extraKnownMarketplaces"] || {})
+        settings["enabledPlugins"] = { PLUGIN => true }.merge(settings["enabledPlugins"] || {})
+        "#{JSON.pretty_generate(settings)}\n"
+      end
+    end
+  end
+end

data/lib/generators/packrat/templates/initializer.rb.tt

@@ -0,0 +1,12 @@
+# Sends your app's exceptions, traces and logs to Packrat: https://packrat.sh/docs/ruby-on-rails
+# PACKRAT_INGEST_KEY, when it is set, wins over the key written here.
+Packrat.configure do |config|
+<% if ingest_key.empty? -%>
+  config.ingest_key = ENV["PACKRAT_INGEST_KEY"]
+<% else -%>
+  config.ingest_key = ENV.fetch("PACKRAT_INGEST_KEY", <%= ingest_key.inspect %>)
+<% end -%>
+<% unless ingest_url.empty? -%>
+  config.ingest_url = <%= ingest_url.inspect %>
+<% end -%>
+end

data/lib/packrat/config.rb

@@ -0,0 +1,139 @@
+require "socket"
+require "uri"
+
+module Packrat
+  # Everything the gem reads, all of it from the environment. An OTEL_* variable that is set always
+  # wins: the gem fills in only what the standard variables leave empty.
+  class Config
+    DEFAULT_URL = "https://ingest.packrat.sh".freeze
+    INSTRUMENTATIONS = %w[rack action_pack action_view active_job active_record net_http pg mysql2 sidekiq redis aws_sdk concurrent_ruby rake logger].freeze
+    COMMIT_VARIABLES = %w[BUILD_COMMIT HEROKU_SLUG_COMMIT SOURCE_VERSION].freeze
+    REDACTED = "[redacted]".freeze
+    DISTRO_ATTRIBUTES = { "telemetry.distro.name" => "packrat-rails", "telemetry.distro.version" => VERSION }.freeze
+
+    attr_reader :rails_env, :app_name
+    attr_writer :ingest_key, :ingest_url
+
+    def initialize(env: ENV, rails_env: nil, app_name: nil)
+      @env = env
+      @rails_env = rails_env.to_s
+      @app_name = app_name
+    end
+
+    # The variable wins over the initializer, so a deploy can change the key without a commit.
+    def key
+      present(@env["PACKRAT_INGEST_KEY"]) || present(@ingest_key)
+    end
+
+    def url
+      (present(@env["PACKRAT_INGEST_URL"]) || present(@ingest_url) || DEFAULT_URL).chomp("/")
+    end
+
+    def traces_endpoint
+      "#{url}/v1/traces"
+    end
+
+    def logs_endpoint
+      "#{url}/v1/logs"
+    end
+
+    def headers
+      { "Authorization" => key }
+    end
+
+    # Why the gem does nothing, or nil when it runs. Test is silent: a line per test process is noise.
+    def off_reason
+      if rails_env == "test" then nil
+      elsif flag?("PACKRAT_DISABLED") then "PACKRAT_DISABLED is set, so nothing is sent"
+      elsif sdk_disabled? then "OTEL_SDK_DISABLED is true, so nothing is sent"
+      elsif key.nil? then "no ingest key is set (PACKRAT_INGEST_KEY or config.ingest_key), so nothing is sent"
+      end
+    end
+
+    def enabled?
+      allowed? && !key.nil?
+    end
+
+    # Everything but the key. The middleware is placed before config/initializers set the key.
+    def allowed?
+      rails_env != "test" && !flag?("PACKRAT_DISABLED") && !sdk_disabled?
+    end
+
+    # PACKRAT_OTEL_INSTRUMENTATIONS=sidekiq,-pg adds sidekiq to the allowlist and takes pg out.
+    def instrumentations
+      @env["PACKRAT_OTEL_INSTRUMENTATIONS"].to_s.split(",").map(&:strip).reject(&:empty?)
+        .reduce(INSTRUMENTATIONS.dup) do |names, entry|
+          entry.start_with?("-") ? names - [ entry.delete_prefix("-") ] : names | [ entry ]
+        end
+    end
+
+    def service_name
+      present(@env["OTEL_SERVICE_NAME"]) || env_attributes["service.name"] || app_name
+    end
+
+    def environment
+      env_attributes["deployment.environment.name"] || env_attributes["deployment.environment"] || rails_env
+    end
+
+    def service_version
+      env_attributes["service.version"] || COMMIT_VARIABLES.lazy.map { |name| present(@env[name]) }.find(&:itself)
+    end
+
+    # Only what the standard variables leave unset; the SDK's default resource already holds theirs.
+    def resource_attributes
+      {}.tap do |attributes|
+        attributes["service.name"] = app_name if app_name && service_name == app_name
+        unless env_attributes.key?("deployment.environment.name") || env_attributes.key?("deployment.environment")
+          attributes["deployment.environment.name"] = rails_env
+        end
+        version = service_version
+        attributes["service.version"] = version if version && !env_attributes.key?("service.version")
+        # DYNO names the process on Heroku and build.io: web.1, worker.2.
+        attributes["service.instance.id"] = present(@env["DYNO"]) || Socket.gethostname unless env_attributes.key?("service.instance.id")
+        # Packrat reads telemetry.distro.name to tell this gem's data from a hand-built setup.
+        DISTRO_ATTRIBUTES.each { |name, value| attributes[name] = value unless env_attributes.key?(name) }
+      end
+    end
+
+    def set?(name)
+      !present(@env[name]).nil?
+    end
+
+    # The app's own exporter names the ingest host, so a second exporter would send every span twice.
+    def app_exports_to_packrat?
+      ours = URI(url).then { |uri| [ uri.host, uri.port ] }
+      %w[OTEL_EXPORTER_OTLP_ENDPOINT OTEL_EXPORTER_OTLP_TRACES_ENDPOINT].any? do |name|
+        (URI(present(@env[name]).to_s).then { |uri| [ uri.host, uri.port ] } rescue nil) == ours
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} url=#{url} key=#{key ? REDACTED : 'unset'} service=#{service_name} environment=#{environment}>"
+    end
+    alias to_s inspect
+
+    private
+
+    # The SDK reads OTEL_RESOURCE_ATTRIBUTES the same way: split on commas, then on "=".
+    def env_attributes
+      @env_attributes ||= @env["OTEL_RESOURCE_ATTRIBUTES"].to_s.split(",").filter_map do |pair|
+        name, value = pair.split("=", 2).map { |part| part.to_s.strip }
+        [ name, value ] unless name.empty? || value.empty?
+      end.to_h
+    end
+
+    def sdk_disabled?
+      @env["OTEL_SDK_DISABLED"].to_s.strip.casecmp?("true")
+    end
+
+    def flag?(name)
+      value = present(@env[name])
+      !value.nil? && !%w[0 false no].include?(value.downcase)
+    end
+
+    def present(value)
+      value = value.to_s.strip
+      value.empty? ? nil : value
+    end
+  end
+end

data/lib/packrat/otel/error_spans.rb

@@ -0,0 +1,71 @@
+require "json"
+
+module Packrat
+  module Otel
+    # Everything Rails.error hears -- an error that escapes a request or a job, one the app rescues and
+    # reports itself, one in a runner script -- recorded on the span it happened in, or on a span of its
+    # own when there is none.
+    class ErrorSpans
+      NAME = "Rails.error"
+      # Rails puts the live controller and job objects in the context.
+      SKIPPED_KEYS = %i[controller job].freeze
+      # Rails reports these after the request or job instrumentation has recorded the same error.
+      INSTRUMENTED_SOURCES = %w[application.action_dispatch job.sidekiq].freeze
+      # A cache failure falls back to the source of truth; Sentry skips these too.
+      CACHE_STORE_SOURCE = /_cache_store\.active_support\z/
+
+      def report(error, handled:, severity:, context:, source: nil)
+        return if skipped?(handled, source)
+
+        exception = error.is_a?(Exception) ? error : RuntimeError.new(error.to_s)
+        attributes = exception_attributes(exception, handled, severity, source).merge(context_attributes(context))
+        span = OpenTelemetry::Trace.current_span
+        return span.record_exception(exception, attributes:) if span.recording?
+
+        span = OpenTelemetry.tracer_provider.tracer("rails.error").start_root_span(NAME)
+        span.record_exception(exception, attributes:)
+        span.finish
+      rescue StandardError => error
+        OpenTelemetry.handle_error(exception: error, message: "Packrat::Otel::ErrorSpans#report failed")
+      end
+
+      private
+
+      def skipped?(handled, source)
+        (!handled && INSTRUMENTED_SOURCES.include?(source)) || CACHE_STORE_SOURCE.match?(source.to_s)
+      end
+
+      # Span events are not scrubbed on export, so the message and the stack are scrubbed here.
+      def exception_attributes(exception, handled, severity, source)
+        {
+          "exception.message" => scrub(exception.message),
+          "exception.stacktrace" => scrub(exception.full_message(highlight: false, order: :top)),
+          "exception.handled" => handled,
+          "rails.error.severity" => severity.to_s,
+          "rails.error.source" => source
+        }.compact
+      end
+
+      def context_attributes(context)
+        values = context.except(*SKIPPED_KEYS, :tags)
+        values = values.merge(context[:tags]) if context[:tags].is_a?(Hash)
+
+        values.each_with_object({}) do |(key, value), attributes|
+          attributes["rails.error.context.#{key}"] = attribute_value(value) unless value.nil?
+        end
+      end
+
+      def attribute_value(value)
+        case value
+        when Integer, Float, true, false then value
+        when Hash, Array then scrub(value.to_json)
+        else scrub(value.to_s)
+        end
+      end
+
+      def scrub(text)
+        Scrubber.scrub_text(text.to_s.encode("UTF-8", invalid: :replace, undef: :replace, replace: "�"))
+      end
+    end
+  end
+end

data/lib/packrat/otel/root_kind_sampler.rb

@@ -0,0 +1,25 @@
+module Packrat
+  module Otel
+    # A trace that starts with a request (server) or a job (consumer) is work. One that starts with
+    # anything else is a poll: Solid Queue and Solid Cable each ask Postgres for work about ten times
+    # a second, and every poll would otherwise be a trace of its own. Children never reach this class;
+    # parent_based routes only roots here, and a child follows its root. A Rake task is work too,
+    # though its span is internal; when Rails boots inside the task, the root is its execute.
+    class RootKindSampler
+      KEEP = %i[server consumer].freeze
+      NAMES = [ ErrorSpans::NAME, "rake.invoke", "rake.execute" ].freeze
+
+      def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+        keep = KEEP.include?(kind) || NAMES.include?(name)
+        decision = keep ? OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_AND_SAMPLE
+                        : OpenTelemetry::SDK::Trace::Samplers::Decision::DROP
+        tracestate = OpenTelemetry::Trace.current_span(parent_context).context.tracestate
+        OpenTelemetry::SDK::Trace::Samplers::Result.new(decision:, tracestate:)
+      end
+
+      def description
+        "RootKindSampler{#{KEEP.join(',')}}"
+      end
+    end
+  end
+end

data/lib/packrat/otel/scrubber.rb

@@ -0,0 +1,111 @@
+require "cgi"
+
+module Packrat
+  module Otel
+    # Removes credentials before telemetry leaves the process. Packrat archives raw data and never
+    # rewrites it, so anything that survives here is kept for good.
+    #
+    # Query strings are kept on purpose: they carry what a request was about, which is most of what
+    # a trace is read for. Only the values of credential-named parameters are replaced.
+    module Scrubber
+      REDACTED = "[REDACTED]".freeze
+      URL_KEYS = %w[http.target http.url url.full url.query].freeze
+      HEADER_PREFIXES = %w[http.request.header. http.response.header.].freeze
+      # A whole parameter name, or one segment of a snake_case name: api_key and access_token match,
+      # keyword and monkey do not.
+      CREDENTIAL_PARAM = /\A(?:[a-z0-9]+_)*(?:key|token|password|passwd|secret|signature|sig|auth|credential)(?:_[a-z0-9]+)*\z/i
+      # Free text is redacted by pattern: log lines and error messages interpolate URLs, which is
+      # where a credential usually appears.
+      CREDENTIAL_IN_TEXT = /
+        (?<name>\b(?:[a-z0-9]+_)?(?:api_key|access_token|key|token|password|passwd|secret|signature|sig|auth|credential)\s*=\s*)
+        (?<value>[^\s&"'<>\]]+)
+      /ix
+      BEARER = %r{\b(?<scheme>Bearer|Basic)\s+(?<value>[A-Za-z0-9._~+/-]+=*)}i
+      ANSI = /\e\[[0-9;]*m/
+
+      class << self
+        def scrub_text(text)
+          return text unless text.is_a?(String)
+
+          text.gsub(CREDENTIAL_IN_TEXT) { "#{Regexp.last_match(:name)}#{REDACTED}" }
+              .gsub(BEARER) { "#{Regexp.last_match(:scheme)} #{REDACTED}" }
+        end
+
+        # The same hash when nothing needs to change, so callers can tell by identity.
+        def scrub_attributes(attributes)
+          return attributes if attributes.nil?
+          return attributes unless attributes.any? { |key, value| header?(key) || redactable_url?(key, value) }
+
+          attributes.each_with_object({}) do |(key, value), scrubbed|
+            next if header?(key)
+
+            scrubbed[key] = URL_KEYS.include?(key) ? redact_query(value) : value
+          end
+        end
+
+        # SpanData and LogRecordData are frozen structs, so a changed one is rebuilt from its fields.
+        def scrub_spans(spans)
+          spans.map do |span|
+            attributes = scrub_attributes(span.attributes)
+            attributes.equal?(span.attributes) ? span : span.class.new(*span.to_h.merge(attributes:).values)
+          end
+        end
+
+        def scrub_log_records(records)
+          records.map do |record|
+            attributes = scrub_attributes(record.attributes)
+            body = record.body.is_a?(String) ? scrub_text(record.body.gsub(ANSI, "")) : record.body
+            next record if attributes.equal?(record.attributes) && body == record.body
+
+            record.class.new(*record.to_h.merge(attributes:, body:).values)
+          end
+        end
+
+        private
+
+        def header?(key)
+          HEADER_PREFIXES.any? { |prefix| key.to_s.start_with?(prefix) }
+        end
+
+        def redactable_url?(key, value)
+          URL_KEYS.include?(key) && value.to_s.include?("=")
+        end
+
+        def redact_query(url)
+          head, separator, query = url.to_s.include?("?") ? url.to_s.partition("?") : [ "", "", url.to_s ]
+          return url if query.empty?
+
+          redacted = query.split("&").map do |pair|
+            name, equals, _value = pair.partition("=")
+            equals.empty? || !CREDENTIAL_PARAM.match?(CGI.unescape(name)) ? pair : "#{name}=#{REDACTED}"
+          end
+          "#{head}#{separator}#{redacted.join('&')}"
+        end
+      end
+    end
+
+    class ScrubbingSpanExporter
+      def initialize(exporter)
+        @exporter = exporter
+      end
+
+      def export(spans, timeout: nil)
+        @exporter.export(Scrubber.scrub_spans(spans), timeout:)
+      end
+
+      def force_flush(timeout: nil)
+        @exporter.force_flush(timeout:)
+      end
+
+      def shutdown(timeout: nil)
+        @exporter.shutdown(timeout:)
+      end
+    end
+
+    class ScrubbingLogExporter < ScrubbingSpanExporter
+      def export(records, timeout: nil)
+        @exporter.export(Scrubber.scrub_log_records(records), timeout:)
+      end
+    end
+  end
+end

data/lib/packrat/otel.rb

@@ -0,0 +1,250 @@
+require "uri"
+
+module Packrat
+  module Otel
+    CLASSES = {
+      "rack" => "OpenTelemetry::Instrumentation::Rack",
+      "action_pack" => "OpenTelemetry::Instrumentation::ActionPack",
+      "active_job" => "OpenTelemetry::Instrumentation::ActiveJob",
+      "active_record" => "OpenTelemetry::Instrumentation::ActiveRecord",
+      "net_http" => "OpenTelemetry::Instrumentation::Net::HTTP",
+      "pg" => "OpenTelemetry::Instrumentation::PG",
+      "mysql2" => "OpenTelemetry::Instrumentation::Mysql2",
+      "logger" => "OpenTelemetry::Instrumentation::Logger"
+    }.freeze
+    # The health check runs every few seconds and would otherwise be most of what is stored.
+    OPTIONS = { "rack" => { untraced_endpoints: [ "/up" ] } }.freeze
+    # These install through the Active Support instrumentation and do not require it themselves.
+    PREREQUISITES = { "action_view" => "active_support" }.freeze
+    # These set up in an after_initialize block of their own Railtie, which cannot run once boot has
+    # reached Packrat's.
+    BOOT_ONLY = %w[action_mailer active_storage].freeze
+    ACTION_VIEW_EVENTS = %w[render_template render_partial render_collection render_layout].map { |event| "#{event}.action_view" }.freeze
+    EXIT_TIMEOUT = 5
+
+    # dogstatsd-ruby defines Datadog::Statsd without the tracer, hence the method check.
+    def self.datadog?
+      !!(defined?(::Datadog) && ::Datadog.respond_to?(:configuration))
+    end
+
+    # The one decision, made at the end of boot: configure OpenTelemetry when nothing has, add a
+    # Packrat exporter beside the app's own when something has, and stay out of Datadog's way.
+    class Setup
+      attr_reader :outcome, :line, :installed, :warnings
+
+      def initialize(config:, logger:, errors:)
+        @config = config
+        @logger = logger
+        @errors = errors
+        @installed = []
+        @warnings = []
+      end
+
+      def call
+        provider = OpenTelemetry.tracer_provider
+        if !@config.enabled? then off
+        elsif Otel.datadog? then datadog
+        elsif provider.is_a?(OpenTelemetry::SDK::Trace::TracerProvider) then append(provider)
+        else configure
+        end
+        @logger.info(@line) if @line
+        self
+      end
+
+      # The Rack span, for the middleware the Railtie put in the stack before this decision was made.
+      def rack(app)
+        return app unless @outcome == :configured && @installed.include?("rack")
+
+        middleware, *args = instrumentation("rack").middleware_args
+        middleware.new(app, *args)
+      rescue StandardError, LoadError => error
+        failed("rack middleware", error)
+        app
+      end
+
+      private
+
+      def off
+        @outcome = :off
+        @line = @config.off_reason && "Packrat: #{@config.off_reason}"
+      end
+
+      def datadog
+        @outcome = :datadog
+        @line = "Packrat: Datadog found; configure the Agent to dual-ship, see https://packrat.sh/docs/datadog"
+      end
+
+      def configure
+        logs = step("logs SDK") { load_logs }
+        spans = step("traces exporter") { span_processor }
+        records = logs && step("logs exporter") { log_record_processor }
+        return @line = "Packrat: OpenTelemetry was not configured, so nothing is sent" unless spans && step("SDK") { configure_sdk(spans, records) }
+
+        @outcome = :configured
+        step("sampler") { use_sampler } unless @config.set?("OTEL_TRACES_SAMPLER")
+        @config.instrumentations.each { |name| step("instrumentation #{name}") { install(name) } }
+        step("Rails.error") { @errors.subscribe(ErrorSpans.new) }
+        step("at_exit") { at_exit { shutdown_providers } }
+        @line = "Packrat: sending #{signals(records)} for #{@config.service_name}/#{@config.environment} " \
+                "to #{@config.url} (#{@installed.join(', ')})"
+      end
+
+      def append(provider)
+        if @config.app_exports_to_packrat?
+          @outcome = :already
+          return @line = "Packrat: the app's OpenTelemetry exporter already sends to #{@config.url}"
+        end
+
+        spans = step("traces exporter") { span_processor }
+        return @line = "Packrat: the app's OpenTelemetry was left alone, and nothing is sent" unless spans && step("traces processor") { provider.add_span_processor(spans) }
+
+        @outcome = :appended
+        records = sdk_logger_provider && logger_instrumented? && step("logs exporter") { log_record_processor }
+        records = nil unless records && step("logs processor") { sdk_logger_provider.add_log_record_processor(records) }
+        errors = !error_spans? && step("Rails.error") { @errors.subscribe(ErrorSpans.new) }
+        step("at_exit") { at_exit { [ spans, records ].compact.each { |processor| processor.shutdown(timeout: EXIT_TIMEOUT) } } }
+
+        attributes = provider.resource.attribute_enumerator.to_h
+        name = attributes["service.name"]
+        environment = attributes["deployment.environment.name"] || attributes["deployment.environment"]
+        @line = "Packrat: sending a copy of the app's #{signals(records)} for #{name}/#{environment} to #{@config.url}"
+        @line += "; Rails.error is now recorded on spans, which the app's own exporter also receives" if errors
+        if name.nil? || name.start_with?("unknown_service")
+          @line += ". Warning: the app's OpenTelemetry resource has no service.name, and the setup screen looks for the app by name"
+        end
+      end
+
+      # Every step fails on its own: a warning that names it, and boot goes on. LoadError is not a
+      # StandardError, and a missing gem is the likely failure.
+      def step(name)
+        yield || true
+      rescue StandardError, LoadError => error
+        failed(name, error)
+        nil
+      end
+
+      def failed(name, error)
+        text = Packrat.redact(error.message.lines.first.to_s.strip, @config.key)
+        message = "Packrat: #{name} failed (#{error.class}: #{text}); the app runs without it"
+        @warnings << message
+        @logger.warn(message)
+      end
+
+      # Required here rather than at the top of the gem: the logs SDK prepends a hook to
+      # SDK::Configurator, and an app that configures OpenTelemetry itself would then get a logger
+      # provider exporting to localhost:4318 that it never asked for.
+      def load_logs
+        require "opentelemetry-logs-sdk"
+        require "opentelemetry-exporter-otlp-logs"
+      end
+
+      def span_processor
+        OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(
+          ScrubbingSpanExporter.new(OpenTelemetry::Exporter::OTLP::Exporter.new(endpoint: @config.traces_endpoint, headers: @config.headers))
+        )
+      end
+
+      def log_record_processor
+        OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(
+          ScrubbingLogExporter.new(OpenTelemetry::Exporter::OTLP::Logs::LogsExporter.new(endpoint: @config.logs_endpoint, headers: @config.headers))
+        )
+      rescue NameError => error
+        raise unless error.name == :Utilities
+
+        # The logs exporter from 0.6 calls Common::Utilities, which otlp-common has from 0.3, and still
+        # declares "~> 0.2"; Bundler keeps an older lock. A bound in the gemspec would need Ruby 3.3.
+        raise NameError, "#{error.message}; run bundle update opentelemetry-exporter-otlp-common"
+      end
+
+      def configure_sdk(spans, records)
+        OpenTelemetry::SDK.configure do |sdk|
+          sdk.resource = OpenTelemetry::SDK::Resources::Resource.create(@config.resource_attributes)
+          sdk.add_span_processor(spans)
+          sdk.add_log_record_processor(records) if records
+        end
+      end
+
+      def use_sampler
+        OpenTelemetry.tracer_provider.sampler =
+          OpenTelemetry::SDK::Trace::Samplers.parent_based(root: RootKindSampler.new)
+      end
+
+      def install(name)
+        raise ArgumentError, "the #{name} instrumentation must load before boot ends, which Packrat does not do" if BOOT_ONLY.include?(name)
+
+        require "opentelemetry-instrumentation-#{PREREQUISITES[name]}" if PREREQUISITES[name]
+        require "opentelemetry-instrumentation-#{name}"
+        skip_railtie(name) if %w[action_pack action_view].include?(name)
+        return unless instrumentation(name).install(OPTIONS.fetch(name, {}))
+
+        subscribe_action_view if name == "action_view"
+
+        prerequisite = PREREQUISITES[name]
+        @installed << prerequisite if prerequisite && !@installed.include?(prerequisite) && instrumentation(prerequisite).installed?
+        @installed << name
+      end
+
+      # Action Pack's install loads a Railtie whose one job is to put the Rack span in the middleware
+      # stack. At the end of boot the stack is frozen, so loading it raises; Packrat::RackSpan does
+      # that job, and the file is marked as loaded instead. Action View's is skipped too: see
+      # subscribe_action_view.
+      def skip_railtie(name)
+        _, path = $LOAD_PATH.resolve_feature_path("opentelemetry/instrumentation/#{name}/railtie")
+        path = File.realpath(path)
+        $LOADED_FEATURES << path unless $LOADED_FEATURES.include?(path)
+      end
+
+      # Action View's Railtie subscribes in config.after_initialize. Loaded while Packrat's own
+      # after_initialize block runs, that block runs at once and again when Rails reaches it in the
+      # list it is walking. Two subscribers share one payload key, so every render left a context
+      # attached and each later request on the thread became a child of the last.
+      def subscribe_action_view
+        instrumentation("active_support").install({})
+        action_view = instrumentation("action_view")
+        formatter = OpenTelemetry::Instrumentation::ActiveSupport::LEGACY_NAME_FORMATTER if action_view.config[:legacy_span_names]
+        ACTION_VIEW_EVENTS.each do |event|
+          OpenTelemetry::Instrumentation::ActiveSupport.subscribe(
+            action_view.tracer, event, action_view.config[:notification_payload_transform],
+            action_view.config[:disallowed_notification_payload_keys], span_name_formatter: formatter
+          )
+        end
+      end
+
+      def instrumentation(name)
+        namespace = CLASSES[name] || begin
+          constant = OpenTelemetry::Instrumentation.constants.find { |found| found.to_s.downcase == name.delete("_") }
+          "OpenTelemetry::Instrumentation::#{constant || raise(NameError, "no instrumentation named #{name}")}"
+        end
+        Object.const_get("#{namespace}::Instrumentation").instance
+      end
+
+      def shutdown_providers
+        OpenTelemetry.tracer_provider.shutdown(timeout: EXIT_TIMEOUT)
+        OpenTelemetry.logger_provider.shutdown(timeout: EXIT_TIMEOUT) if sdk_logger_provider
+      end
+
+      def sdk_logger_provider
+        return unless defined?(OpenTelemetry::SDK::Logs::LoggerProvider) && OpenTelemetry.respond_to?(:logger_provider)
+
+        provider = OpenTelemetry.logger_provider
+        provider if provider.is_a?(OpenTelemetry::SDK::Logs::LoggerProvider)
+      end
+
+      # A logger provider nothing writes to is common: the logs SDK makes one whenever it is loaded,
+      # and an app may send its log lines through a provider of its own.
+      def logger_instrumented?
+        defined?(OpenTelemetry::Instrumentation::Logger::Instrumentation) &&
+          OpenTelemetry::Instrumentation::Logger::Instrumentation.instance.installed?
+      end
+
+      # ActiveSupport::ErrorReporter keeps its subscribers private.
+      def error_spans?
+        Array(@errors.instance_variable_get(:@subscribers)).any? { |subscriber| subscriber.class.name.to_s.end_with?("ErrorSpans") }
+      end
+
+      def signals(records)
+        records ? "traces and logs" : "traces"
+      end
+    end
+  end
+end

data/lib/packrat/rack_span.rb

@@ -0,0 +1,23 @@
+module Packrat
+  # The Rack instrumentation is middleware, and the stack is built before the end of boot, where
+  # Packrat decides whether it configures OpenTelemetry at all. So the Railtie puts this in early,
+  # and it becomes the Rack span or passes every request straight through once that is decided.
+  class RackSpan
+    def initialize(app)
+      @app = app
+      @lock = Mutex.new
+    end
+
+    def call(env)
+      (@inner || inner).call(env)
+    end
+
+    private
+
+    def inner
+      return @app unless Packrat.setup
+
+      @lock.synchronize { @inner ||= Packrat.setup.rack(@app) }
+    end
+  end
+end

data/lib/packrat/railtie.rb

@@ -0,0 +1,23 @@
+require "rails/railtie"
+
+module Packrat
+  class Railtie < Rails::Railtie
+    initializer "packrat.middleware" do |app|
+      Packrat.guard("middleware") do
+        app.config.middleware.insert_before(0, RackSpan) if Packrat.config.allowed? && !Otel.datadog?
+      end
+    end
+
+    # The decision must come after every after_initialize block, so that an app that configures
+    # OpenTelemetry late has done so. to_prepare runs after config/initializers registered theirs, so
+    # a block registered here is the last. An initializer declared after: :finisher_hook is not the
+    # same thing: the sort pulls the whole Finisher ahead of config/initializers. to_prepare runs
+    # again on every reload in development, hence the flag.
+    config.to_prepare do
+      next if Packrat.registered
+
+      Packrat.registered = true
+      Rails.application.config.after_initialize { Packrat.guard("boot") { Packrat.start } }
+    end
+  end
+end

data/lib/packrat/version.rb

@@ -0,0 +1,3 @@
+module Packrat
+  VERSION = "0.1.0"
+end

data/lib/packrat-rails.rb

@@ -0,0 +1 @@
+require_relative "packrat"

data/lib/packrat.rb

@@ -0,0 +1,48 @@
+require "logger"
+require "opentelemetry/sdk"
+require "opentelemetry/exporter/otlp"
+require_relative "packrat/version"
+require_relative "packrat/config"
+require_relative "packrat/otel/scrubber"
+require_relative "packrat/otel/error_spans"
+require_relative "packrat/otel/root_kind_sampler"
+require_relative "packrat/otel"
+require_relative "packrat/rack_span"
+require_relative "packrat/railtie" if defined?(Rails::Railtie)
+
+module Packrat
+  class << self
+    attr_reader :setup
+    attr_accessor :registered
+
+    def config
+      @config ||= Config.new(
+        env: ENV, rails_env: Rails.env, app_name: Rails.application.class.module_parent_name.underscore
+      )
+    end
+
+    # Packrat.configure { |config| config.ingest_key = "..." }, from config/initializers/packrat.rb.
+    def configure
+      yield config
+    end
+
+    # An app adds to what the gem configured with ActiveSupport.on_load(:packrat) { |setup| ... }.
+    def start
+      @setup = Otel::Setup.new(config:, logger: Rails.logger, errors: Rails.error).call
+      ActiveSupport.run_load_hooks(:packrat, @setup)
+    end
+
+    # The outermost catch: whatever goes wrong, the app boots without Packrat.
+    def guard(name)
+      yield
+    rescue StandardError, LoadError => error
+      key = (config.key rescue nil)
+      Rails.logger&.warn("Packrat: #{name} failed (#{error.class}: #{redact(error.message, key)}); the app runs without it")
+      nil
+    end
+
+    def redact(text, key)
+      key ? text.to_s.gsub(key, Config::REDACTED) : text.to_s
+    end
+  end
+end

metadata

@@ -0,0 +1,323 @@
+--- !ruby/object:Gem::Specification
+name: packrat-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Packrat Labs
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-10-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.26'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.26'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-logs-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-exporter-otlp-logs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.24'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.24'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-action_pack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-active_job
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-active_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-net_http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.27'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.27'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.27'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.27'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.25'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.25'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-action_view
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.25'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.25'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-aws_sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-concurrent_ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: opentelemetry-instrumentation-logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/generators/packrat/packrat_generator.rb
+- lib/generators/packrat/templates/initializer.rb.tt
+- lib/packrat-rails.rb
+- lib/packrat.rb
+- lib/packrat/config.rb
+- lib/packrat/otel.rb
+- lib/packrat/otel/error_spans.rb
+- lib/packrat/otel/root_kind_sampler.rb
+- lib/packrat/otel/scrubber.rb
+- lib/packrat/rack_span.rb
+- lib/packrat/railtie.rb
+- lib/packrat/version.rb
+homepage: https://packrat.sh/docs/ruby-on-rails
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/packratlabs/packrat-rails
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: OpenTelemetry for Rails, configured to send to Packrat with one key
+test_files: []