forge_ops_tracker 0.14.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b7f1809933ffeccac536f117de7c234002826fe29414fc3fa92f12c22bb1a18
-  data.tar.gz: 84a9edadbaeb72dbe62164a84f26c7f23b6a600f176126ca82370709dc72b5c3
+  metadata.gz: 81c08199bfeae97d20295b7c04a46dc3b9dd9be519d4790404b88e2ca514fbe1
+  data.tar.gz: dad1efa10164cebcbce9452c1f903812157143e871162076f09298ebf41a6ea7
 SHA512:
-  metadata.gz: ca419d26d17f08e4544bb213c2949dedf7001402f163a15b0def3c0942ffcc534637911d1bc7e8890f6a3dc556f174a3ecea703351fe291d492c1c151838e3f9
-  data.tar.gz: 6890f1adbbf73ae399699ee3482a005bbfee521909c6af6acedb8a805a2aa69c3d46f75bf33a3a4722be9f0e6e84a0263850729e42380d1d1b26e23e50f285cb
+  metadata.gz: 2a32b34300ee005cd09be7f188275091ec9ba8cf4ef2e65044176a7e6d1427feef170cbc44dbd9f7a25dcf0073b2afb6186db3db2069a5737bfdcb274e62cc7f
+  data.tar.gz: 4431641c5e95f757dd82e7af0015de824804610ee4ebf252cbe3a4db13ca5f5aa1cac5fda274a94833be652a9d6c5e25ab4406570d4790b165cf242f8490ff66

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.15.1 (2026-10-01)
+
+- Errors reported just before a process exits are now sent before it ends. Delivery runs on a
+  background thread, and a short-lived process (a rake task, a cron script, `rails runner`,
+  including the test command on a project's setup page) could exit before that thread sent them,
+  so they never arrived. On a normal exit the queue now sends what's left, waiting at most 5
+  seconds, and only in a process that reported something.
+
+## 0.15.0 (2026-09-29)
+
+- SQL masking now also catches strings with a backslash-escaped quote (`'o\'brien'`,
+  `E'o\'brien'`), prefixed strings (`E''`, `X''`, `N''`, `B''`, `U&''`, prefix included), hex,
+  binary and exponent numbers (`0x1F`, `0b101`, `3e10`, `1.5E-3`, `.5`), and, on MySQL and
+  MariaDB, `"double-quoted"` strings. `SqlStatement.mask` takes an optional `system:`, and
+  database spans (including `ForgeOpsTracker.span`'s `db_system:`) pass their `db.system` to it.
+
 ## 0.14.0 (2026-09-25)
 
 - Every Active Record database span now carries the query's SQL (`db.statement`), masked so every

data/README.md

@@ -416,9 +416,12 @@ on error events is sent either way.
 Every Active Record query span carries the query's SQL and the database it ran on, so a slow trace
 shows exactly which query was slow. The SQL is masked before it leaves your process: every string
 and number is replaced by `?`, so `WHERE email = 'a@b.co' AND id = 42` is sent as
-`WHERE email = ? AND id = ?`, and bind values are never sent at all. ForgeOps masks it again on
-arrival. The database comes from the connection's adapter (`postgresql`, `mysql`, `sqlite`,
-`mssql`, `oracle`, or the adapter's own name otherwise).
+`WHERE email = ? AND id = ?`, and bind values are never sent at all. That includes escaped and
+prefixed strings (`E'o\'brien'`, `X'DEADBEEF'`), hex, binary and exponent numbers (`0x1F`,
+`0b101`, `1.5E-3`), and, on MySQL and MariaDB (where `"double quotes"` hold a string, not a name),
+double-quoted strings. ForgeOps masks it again on arrival. The database comes from the
+connection's adapter (`postgresql`, `mysql`, `sqlite`, `mssql`, `oracle`, or the adapter's own
+name otherwise).
 
 Spans you create yourself can carry SQL too. Pass `statement:` (and optionally `db_system:`) on a
 `kind: "database"` span; it's masked the same way:

data/lib/forge_ops_tracker/delivery_queue.rb

@@ -8,6 +8,11 @@ module ForgeOpsTracker
   # in each forked Puma/Passenger worker process rather than being carried
   # across a fork, which would leave it dead in the child.
   class DeliveryQueue
+    # The most a normal process exit waits for queued events to go out (see #drain): long enough for
+    # one delivery at the default open_timeout + read_timeout, short enough that an unreachable
+    # ForgeOps never holds up a deploy or a cron run for long.
+    DRAIN_TIMEOUT = 5
+
     # deliver_with names the Client method each payload goes through: :deliver (error events) by
     # default, :deliver_change for ForgeOpsTracker.record_change's own queue.
     def initialize(configuration, client: Client.new(configuration), deliver_with: :deliver)
@@ -17,6 +22,28 @@ module ForgeOpsTracker
       @queue = SizedQueue.new(configuration.queue_size)
       @mutex = Mutex.new
       @thread = nil
+      @in_flight = 0
+      @drain_registered = false
+    end
+
+    # Sends whatever is still queued, and lets a delivery already under way finish, before the
+    # process exits, within DRAIN_TIMEOUT. Without it a short-lived process (a rake task, a cron
+    # script, `rails runner`) lost every error it reported in its last moments: the worker thread
+    # dies with the process before it gets to them. Delivers here on the exiting thread rather than
+    # waiting on the worker, which in a forked child is a parent's thread that no longer runs.
+    def drain(timeout: DRAIN_TIMEOUT)
+      deadline = monotonic_now + timeout
+      while monotonic_now < deadline
+        payload = begin
+          @queue.pop(true)
+        rescue ThreadError
+          break
+        end
+        client.public_send(@deliver_with, payload)
+      end
+      sleep 0.01 while @in_flight.positive? && monotonic_now < deadline
+    rescue StandardError => e
+      log { "drain failed: #{e.class}: #{e.message}" }
     end
 
     # Enqueues a payload, dropping it silently (never blocking the caller)
@@ -35,6 +62,7 @@ module ForgeOpsTracker
       attr_reader :configuration, :client
 
       def ensure_worker_started
+        register_drain
         return if @thread&.alive?
 
         @mutex.synchronize do
@@ -47,12 +75,35 @@ module ForgeOpsTracker
 
       def run
         loop do
-          client.public_send(@deliver_with, @queue.pop)
+          payload = @queue.pop
+          @in_flight += 1
+          begin
+            client.public_send(@deliver_with, payload)
+          ensure
+            @in_flight -= 1
+          end
         rescue StandardError => e
           log { "delivery thread error: #{e.class}: #{e.message}" }
         end
       end
 
+      # Registered on the first push, not at load, so a process that never reports anything never
+      # waits on exit at all.
+      def register_drain
+        return if @drain_registered
+
+        @mutex.synchronize do
+          return if @drain_registered
+
+          @drain_registered = true
+          at_exit { drain }
+        end
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
       def log
         configuration.logger&.debug { "[ForgeOpsTracker] #{yield}" }
       end

data/lib/forge_ops_tracker/performance_instrumentation.rb

@@ -84,9 +84,10 @@ module ForgeOpsTracker
     # and number literal becomes "?", so no value the app queried with is ever sent), and which
     # database it ran on, from the connection's adapter. Either is left out when it isn't known.
     def database_span_data(payload)
+      system = db_system(payload[:connection])
       {
-        "db.statement" => SqlStatement.mask(payload[:sql].to_s),
-        "db.system" => db_system(payload[:connection])
+        "db.statement" => SqlStatement.mask(payload[:sql].to_s, system: system),
+        "db.system" => system
       }.compact
     end
 

data/lib/forge_ops_tracker/query_explainer.rb

@@ -102,7 +102,8 @@ module ForgeOpsTracker
       return false unless duration_ms && duration_ms >= configuration.explain_threshold_ms.to_f
 
       connection = payload[:connection]
-      return false unless PerformanceInstrumentation.db_system(connection) == "postgresql"
+      system = PerformanceInstrumentation.db_system(connection)
+      return false unless system == "postgresql"
 
       sql = payload[:sql]
       return false unless self.class.explainable?(sql)
@@ -110,7 +111,7 @@ module ForgeOpsTracker
       pool = connection.respond_to?(:pool) ? connection.pool : nil
       return false unless pool
 
-      statement = SqlStatement.mask(sql)
+      statement = SqlStatement.mask(sql, system: system)
       return false unless reserve(statement)
 
       enqueue(Job.new(

data/lib/forge_ops_tracker/sql_statement.rb

@@ -15,11 +15,19 @@ module ForgeOpsTracker
     MAX_NAME_LENGTH = 200
     MAX_CAUSE_DEPTH = 5
 
-    LITERAL = /
-      '(?:[^']|'')*(?:'|\z)                      # string literal, or one cut off by truncation
-      | (?<tag>\$[A-Za-z_]*\$).*?(?:\k<tag>|\z)  # dollar-quoted string
-      | (?<![\w$.])\d+(?:\.\d+)?(?!\w)           # number, not part of an identifier or placeholder
-    /mx
+    # db.system values where "double quotes" are a string, not a name.
+    DOUBLE_QUOTED_STRING_SYSTEMS = %w[mysql mariadb].freeze
+
+    # The prefix only counts as one when it isn't the end of a word, but the quote always does:
+    # LIKE'%x%', with no space, is still a string. A backslash can be the statement's last character
+    # ('secret\ cut off mid-escape), and the string is still masked to the end.
+    STRING = /(?:(?<![\w$])(?:[EeXxNnBb]|[Uu]&))?'(?:[^'\\]|\\(?:.|\z)|'')*(?:'|\z)/m
+    DOUBLE_QUOTED_STRING = /"(?:[^"\\]|\\(?:.|\z)|"")*(?:"|\z)/m
+    DOLLAR_QUOTED = /(?<tag>\$[A-Za-z_]*\$).*?(?:\k<tag>|\z)/m
+    NUMBER = /(?<![\w$.])(?:0[xX]\h+|0[bB][01]+|(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)(?!\w)/
+
+    LITERAL = Regexp.union(STRING, DOLLAR_QUOTED, NUMBER)
+    LITERAL_WITH_DOUBLE_QUOTES = Regexp.union(STRING, DOUBLE_QUOTED_STRING, DOLLAR_QUOTED, NUMBER)
 
     PART = /(?:[\w$#@]+|"[^"]+"|\[[^\]]+\]|`[^`]+`)/
     NAME = /#{PART}(?:\.#{PART})*/
@@ -51,10 +59,13 @@ module ForgeOpsTracker
       nil
     end
 
-    def mask(statement)
+    # system is the query's db.system, when known: on MySQL and MariaDB "double quotes" are a
+    # string too, so they're masked there and left alone everywhere else.
+    def mask(statement, system: nil)
       return nil if statement.nil? || statement.strip.empty?
 
-      masked = statement.gsub(LITERAL, MASK)
+      pattern = DOUBLE_QUOTED_STRING_SYSTEMS.include?(system.to_s.downcase) ? LITERAL_WITH_DOUBLE_QUOTES : LITERAL
+      masked = statement.gsub(pattern, MASK)
       masked.length > MAX_LENGTH ? "#{masked[0, MAX_LENGTH]}..." : masked
     end
 

data/lib/forge_ops_tracker/version.rb

@@ -1,3 +1,3 @@
 module ForgeOpsTracker
-  VERSION = "0.14.0"
+  VERSION = "0.15.1"
 end

data/lib/forge_ops_tracker.rb

@@ -155,9 +155,10 @@ module ForgeOpsTracker
 
     private
       def database_span_data(data, statement, db_system)
+        system = (db_system.to_s.strip.downcase unless db_system.nil? || db_system.to_s.strip.empty?)
         extra = {
-          "db.statement" => (SqlStatement.mask(statement.to_s) unless statement.nil?),
-          "db.system" => (db_system.to_s.strip.downcase unless db_system.nil? || db_system.to_s.strip.empty?)
+          "db.statement" => (SqlStatement.mask(statement.to_s, system: system) unless statement.nil?),
+          "db.system" => system
         }.compact
         extra.empty? ? data : data.merge(extra)
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: forge_ops_tracker
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.15.1
 platform: ruby
 authors:
 - ForgeOps
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '8.1'
 - !ruby/object:Gem::Dependency
   name: puma
   requirement: !ruby/object:Gem::Requirement