devbench 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61008f8defbff11fd3e079f568739cc25114bc05fb0f8981c5084f83d4770de4
-  data.tar.gz: d0304643c20cdb7fc413771188d60ee1881ae9e760129c22fd32d63aebea0bd5
+  metadata.gz: dd716a7741353f88f381775e58d7d613d7a5d50ff69287feb65f86f25c38e13d
+  data.tar.gz: '03358a6c9d097c8b4adc3daacc8c032699aba2a81814284caa0287254134f95c'
 SHA512:
-  metadata.gz: 8af3f77395bf0f10fddf36e0cdfcfdfd85aa2e1528d08c4abc170eeffd318021d657824d24b8f1dfb8fdba1da71b904760ffffdee84a4d50944ab63f41a3f5db
-  data.tar.gz: c59ffb19a9739467182f6e4bf15b4ad68ebeb18d2eaabb79a17b15a24de40bde6230247bc58d8085368ef7be2b562986360dd0d5e90a45334d63adf739976938
+  metadata.gz: bdc43a37a987bcc745a17bc957d704bbf93835a6ef475c66e7228acb9c64edcad1ee2ab4acd9b68020f21435d16f6cf263e378db615cd49242e20407115e6d9a
+  data.tar.gz: b0c9a3d9884106853d587c2944cb8436bd333ed197fd4630ae17a713e4f959068e96faaf40ea54bfe1cc87f21532f6b482686dd6451ee39d022d9d683e6229d5

data/README.md

@@ -50,7 +50,7 @@ gem (upgrading the gem upgrades the sensor), with **only the public part**
 of `DEVBENCH_DSN`:
 
 ```html
-<script src="https://unpkg.com/devbench@0.6.0/dist/devbench.min.js"
+<script src="https://unpkg.com/devbench@0.7.0/dist/devbench.min.js"
         data-dsn="https://<public>@adt-ingest.onrender.com" data-release="<release>" defer></script>
 ```
 
@@ -76,7 +76,7 @@ All optional except the DSN.
 |---|---|---|
 | `DEVBENCH_DSN` | — (falls back to `ADT_DSN`) | `https://<public>:<secret>@<host>[:port]` from `adt dsn create`. The server authenticates with the secret; the page gets the public part. A 0.5 `https://<key>@<host>` still works (no browser tag, see below). Plain `http://` is accepted only for localhost. |
 | `DEVBENCH_SERVICE` | your app's module, underscored (`AcmeShop` → `acme_shop`); `app` outside Rails; **`<that>-sidekiq` in a Sidekiq process** | Groups this app's issues. Set it and it wins everywhere. |
-| `DEVBENCH_RELEASE` | `GIT_SHA`, `SOURCE_VERSION`, `RENDER_GIT_COMMIT`, else empty | Which deploy an occurrence came from. |
+| `DEVBENCH_RELEASE` | the first found of: a `REVISION` file in `Rails.root` (Capistrano writes one), `HEROKU_SLUG_COMMIT`, `KAMAL_VERSION`, `GITHUB_SHA`, `GIT_SHA`, `SOURCE_VERSION`, `RENDER_GIT_COMMIT`; else empty | Which deploy an occurrence came from. `c.release` in code wins over all of these. |
 | `DEVBENCH_ENABLED` | on | `false` turns everything off: no middleware, no hooks, no tag, nothing sent. |
 
 Or from code, e.g. `config/initializers/devbench.rb`:

data/lib/devbench/config.rb

@@ -109,11 +109,20 @@ module Devbench
   #                      module, underscored (AcmeShop -> acme_shop);
   #                      else "app"; with "-sidekiq" appended in a
   #                      Sidekiq process.
-  #   DEVBENCH_RELEASE   the deployed version. Default: GIT_SHA,
-  #                      SOURCE_VERSION, RENDER_GIT_COMMIT, else "".
+  #   DEVBENCH_RELEASE   the deployed version. Default, first found: the
+  #                      REVISION file in the app root (Capistrano),
+  #                      HEROKU_SLUG_COMMIT, KAMAL_VERSION, GITHUB_SHA,
+  #                      GIT_SHA, SOURCE_VERSION, RENDER_GIT_COMMIT,
+  #                      else "".
   #   DEVBENCH_ENABLED   "false" turns everything off.
   class Configuration
-    RELEASE_FALLBACKS = %w[GIT_SHA SOURCE_VERSION RENDER_GIT_COMMIT].freeze
+    # Tried in order after the REVISION file when no release is configured.
+    # Common deploy tools and platforms only; never an app's own variable.
+    RELEASE_FALLBACKS = %w[HEROKU_SLUG_COMMIT KAMAL_VERSION GITHUB_SHA GIT_SHA SOURCE_VERSION RENDER_GIT_COMMIT].freeze
+    # Capistrano writes the deployed commit here, in the release's root.
+    REVISION_FILE = 'REVISION'
+    # A commit or tag, not a document: read no more than this.
+    REVISION_MAX_BYTES = 255
     OFF = %w[false 0 no off].freeze
 
     # Strings, or nil for "not set".
@@ -125,8 +134,8 @@ module Devbench
     def initialize(env = ENV)
       @dsn = presence(env['DEVBENCH_DSN']) || presence(env['ADT_DSN'])
       @service = presence(env['DEVBENCH_SERVICE'])
-      @release = presence(env['DEVBENCH_RELEASE']) ||
-                 RELEASE_FALLBACKS.lazy.map { |name| presence(env[name]) }.find(&:itself)
+      @release = presence(env['DEVBENCH_RELEASE'])
+      @release_env = RELEASE_FALLBACKS.lazy.map { |name| presence(env[name]) }.find(&:itself)
       @enabled = !OFF.include?(env['DEVBENCH_ENABLED'].to_s.strip.downcase)
       @flush_interval = 60
     end
@@ -149,12 +158,40 @@ module Devbench
       sidekiq_server? ? "#{base}-sidekiq" : base
     end
 
+    # The release sent with every flush and on the browser tag. Explicit
+    # (configure or DEVBENCH_RELEASE) wins; else the REVISION file, read
+    # once reporting starts (after Rails has booted, so Rails.root is
+    # known); else the deploy variables in RELEASE_FALLBACKS order; else "".
     def resolved_release
-      @release.to_s
+      explicit = presence(@release)
+      return explicit if explicit
+
+      @detected_release ||= (revision_file_release || @release_env).to_s
     end
 
     private
 
+    # The first line of <app root>/REVISION, or nil when there is none or it
+    # cannot be read. The app root is Rails.root, else the working directory.
+    def revision_file_release
+      path = File.join(app_root, REVISION_FILE)
+      return nil unless File.file?(path)
+
+      presence(File.open(path, 'rb') { |f| f.read(REVISION_MAX_BYTES) }.to_s.lines.first)
+    rescue StandardError
+      nil
+    end
+
+    def app_root
+      if defined?(::Rails) && ::Rails.respond_to?(:root) && ::Rails.root
+        ::Rails.root.to_s
+      else
+        Dir.pwd
+      end
+    rescue StandardError
+      Dir.pwd
+    end
+
     def sidekiq_server?
       defined?(::Sidekiq) && ::Sidekiq.respond_to?(:server?) && ::Sidekiq.server? ? true : false
     rescue StandardError, SystemStackError

data/lib/devbench/logs.rb

@@ -28,6 +28,10 @@ module Devbench
     MAX_BYTES = 4 * 1024 * 1024
     MAX_AGE = 15 * 60
     MAX_LINE_BYTES = 4096
+    # Lines held from one multi-line message (an exception and its
+    # backtrace): the top of it, so one framework backtrace cannot push the
+    # rest of the request out of a 200-line slice.
+    MAX_MESSAGE_LINES = 50
 
     SEVERITY = %w[DEBUG INFO WARN ERROR FATAL].freeze
     # The last line captured on this thread, and by which hook: see #capture.
@@ -149,7 +153,7 @@ module Devbench
         if message.nil?
           message = block_given? ? yield : progname
         end
-        Logs.capture(severity, message, :broadcast)
+        Logs.capture(severity, message, :broadcast, Logs.broadcast_tags(devbench_broadcast, self))
         true
       rescue StandardError, SystemStackError
         true
@@ -157,7 +161,7 @@ module Devbench
       alias log add
 
       def <<(message)
-        Logs.capture(nil, message, :broadcast) unless Current.trace.nil?
+        Logs.capture(nil, message, :broadcast, Logs.broadcast_tags(devbench_broadcast, self)) unless Current.trace.nil?
         self
       rescue StandardError, SystemStackError
         self
@@ -257,6 +261,17 @@ module Devbench
         []
       end
 
+      # The tag prefixes of the app's loggers in a broadcast (not ours): the
+      # one Rails wrote after each newline of a multi-line message is the
+      # first broadcast's, but which logger is first is the app's choice.
+      # A Proc, so a single-line message never computes it.
+      def broadcast_tags(broadcast, own)
+        lambda do
+          loggers = broadcast&.broadcasts || []
+          loggers.reject { |l| l.equal?(own) }.filter_map { |l| tags_of(l) }
+        end
+      end
+
       # Called by Tee after the logger's own #add returned.
       def tee(logger, severity, message, progname, had_block, yielded, value)
         severity ||= ::Logger::UNKNOWN
@@ -267,32 +282,38 @@ module Devbench
 
           message = had_block ? value : progname
         end
-        capture(severity, message, :tee)
+        capture(severity, message, :tee, -> { tags_of(logger) })
       rescue StandardError, SystemStackError
         nil
       end
 
-      # Keeps one line under the current trace. Never raises.
+      # Keeps one message under the current trace — one entry per line of
+      # it (see #lines_for). Never raises. `tags` is the tag prefix of the
+      # logger written to (an Array of candidates, or a Proc giving one),
+      # needed only for a multi-line message.
       #
       # One line can reach both hooks: in a Sidekiq process Rails.logger may
       # broadcast to Sidekiq.logger. Both run on this thread, one right
       # after the other, so a line equal to the one just captured *by the
       # other hook* is that same write and is skipped. The same hook
       # repeating a line is a real repeat and is kept.
-      def capture(severity, message, source)
+      def capture(severity, message, source, tags = nil)
         return nil unless active?
 
         trace = Current.trace
         return nil if trace.nil?
 
-        line = line_for(trace, severity, message)
+        lines = lines_for(trace, severity, message, tags)
+        return nil if lines.empty?
+
+        written = lines.join("\n")
         last = Thread.current[LAST]
-        if last && last[0] != source && last[1] == line
+        if last && last[0] != source && last[1] == written
           Thread.current[LAST] = nil
           return nil
         end
-        Thread.current[LAST] = [source, line]
-        buffer.push(trace.key, line)
+        Thread.current[LAST] = [source, written]
+        lines.each { |line| buffer.push(trace.key, line) }
         start_polling if @polling_pid != Process.pid
         nil
       rescue StandardError, SystemStackError, ThreadError
@@ -310,11 +331,61 @@ module Devbench
         transport.start if transport.respond_to?(:start)
       end
 
-      # "[v1/s/i/h] INFO message", at most MAX_LINE_BYTES, valid UTF-8.
-      def line_for(trace, severity, message)
+      # "[a] [b] " — what ActiveSupport::TaggedLogging puts before a line,
+      # and what ActionDispatch::DebugExceptions puts after every newline of
+      # the exception it logs as one message. nil when the logger has none.
+      def tags_of(logger)
+        formatter = logger.respond_to?(:formatter) ? logger.formatter : nil
+        return nil unless formatter.respond_to?(:tags_text)
+
+        text = formatter.tags_text.to_s
+        text.empty? ? nil : text
+      end
+
+      # "[v1/s/i/h] INFO message", at most MAX_LINE_BYTES, valid UTF-8 —
+      # one per line of the message. A multi-line message (Rails logs an
+      # exception and its backtrace as one) is split so each line reaches
+      # triage on its own, with the logger's tags removed from the start of
+      # continuation lines (the trace frames each line once) and blank
+      # lines dropped. At most MAX_MESSAGE_LINES; when more, the last says
+      # how many were left out.
+      def lines_for(trace, severity, message, tags)
         label = severity.is_a?(Integer) ? SEVERITY[severity] : nil
+        prefix = label ? "[#{trace}] #{label} " : "[#{trace}] "
         text = message_text(message)
-        line = label ? "[#{trace}] #{label} #{text}" : "[#{trace}] #{text}"
+        text = text.dup.force_encoding(Encoding::UTF_8) unless text.encoding == Encoding::UTF_8
+        text = text.scrub('') unless text.valid_encoding?
+        return [bound_line(prefix + text)] unless text.include?("\n")
+
+        prefixes = tag_prefixes(tags)
+        parts = text.split("\n").each_with_index.filter_map do |part, i|
+          part = untag(part, prefixes) if i.positive?
+          part = part.chomp("\r")
+          part unless part.strip.empty?
+        end
+        return [] if parts.empty?
+
+        if parts.length > MAX_MESSAGE_LINES
+          omitted = parts.length - (MAX_MESSAGE_LINES - 1)
+          parts = parts.first(MAX_MESSAGE_LINES - 1) << "... (#{omitted} more lines)"
+        end
+        parts.map { |part| bound_line(prefix + part) }
+      end
+
+      # A logger whose formatter fails to give its tags costs the untagging,
+      # never the line.
+      def tag_prefixes(tags)
+        Array(tags.respond_to?(:call) ? tags.call : tags).select { |t| t.is_a?(::String) && !t.empty? }
+      rescue StandardError, SystemStackError
+        []
+      end
+
+      def untag(part, prefixes)
+        found = prefixes.find { |p| part.start_with?(p) }
+        found ? part[found.length..] : part
+      end
+
+      def bound_line(line)
         line = line.byteslice(0, MAX_LINE_BYTES) if line.bytesize > MAX_LINE_BYTES
         line = line.dup.force_encoding(Encoding::UTF_8) unless line.encoding == Encoding::UTF_8
         line.valid_encoding? ? line : line.scrub('')

data/lib/devbench/version.rb

@@ -6,5 +6,5 @@ module Devbench
   # The wire format this speaks — the trace header, the handled header, the
   # control-socket message shapes — is what a customer's deployment depends
   # on. See docs/SERVER_SDK_SPEC.md.
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/devbench/view_helper.rb

@@ -10,7 +10,7 @@ module Devbench
   #
   # renders
   #
-  #   <script src="https://unpkg.com/devbench@0.6.0/dist/devbench.min.js"
+  #   <script src="https://unpkg.com/devbench@0.7.0/dist/devbench.min.js"
   #           data-dsn="https://<public>@<host>" data-release="<release>" defer></script>
   #
   # The DSN is the public part of DEVBENCH_DSN only (Devbench.browser_dsn),

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: devbench
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Dev Bench
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies: []
 description: |
   Reports unhandled exceptions, Rails.error reports, failed ActiveJob and