ez_logs_agent 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbc336d9f93ad71ed33b7c76b07965e751eb6b197ae74a4e29a700c6498b2d26
-  data.tar.gz: 1429316f73489ca63f6925d6e5e6bb97a73e6911aefc3f832ec8be125fa9a74d
+  metadata.gz: 96fd8717fab4330e842769b9a4ae03902ccb2487e24c418d54601c99862da306
+  data.tar.gz: e0967b4bfe22b2abb5946c213378a615f3d399a9c0b8d8dd3f002f731bda9444
 SHA512:
-  metadata.gz: 11b8ec5a85a5792c7d4ae0b90b01d46f9e738ba5e043df790b80f81db78da3e19b94611102acfd564388104852a4edf6b91d759f6a4310ffb405a4e97cb38ad0
-  data.tar.gz: acb11f65d81105396c16a5e189aa7437b607becbe46f8910c84828410546ec2ac19752af3f8a22414027623e375fbbdca52b4716c2670c97bd4119d432619ff3
+  metadata.gz: bc502ab7e6ec65dab0f691005e4e0a71a23182a184c2ce1a188933ebe01db1155b3e4e500a59d23e7275c1a836450317a63e262d0d0babbf5123120be1718809
+  data.tar.gz: cc13f82eece53f6deb53c07ad324cf74fce412d06112abfa86c5ca76a829ed01a1cb421a63125489d969ee2e21efb3d9cb03f5b65412db9792330edca30be271

data/CHANGELOG.md

@@ -2,6 +2,44 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.2.1] — 2026-06-05
+
+### Fixed
+- **Bulk-op row counts on Postgres.** The PG adapter does not populate
+  `payload[:row_count]` for plain `DELETE`/`UPDATE` notifications, so
+  the first 0.2.0 builds shipped `row_count: 0` for the cases that
+  matter most. `BulkDatabaseCapturer` now prepends a tiny shim onto
+  `ActiveRecord::Relation#delete_all` / `#update_all` that stashes the
+  returned row count and back-fills it onto the just-pushed event via
+  `Buffer.peek_last`. No change to the wire shape — `row_count` now
+  carries the real number.
+- **Model resolution in Rails dev mode.** `ActiveRecord::Base.descendants`
+  only sees eager-loaded models. The resolver now falls through to
+  `safe_constantize` of the classified table name and verifies the
+  reconstructed class actually owns that table, so bulk ops on
+  lazy-autoloaded models in dev / test no longer silently drop.
+- **Rails Query Log Tags noise in `where_template`.** The parser now
+  strips `/*application='X',action='Y'*/` comments before extracting
+  the WHERE clause, so the humanized filter line on the server reads
+  cleanly instead of leaking the framework's instrumentation tags.
+
+### Changed
+- **Framework-rewrite filter narrowed.** The 0.2.0 filter that swallowed
+  Rails-generated `SET col = NULL` writes was too aggressive — it also
+  hid deliberate "null this column out" operations the customer wrote.
+  The filter now only drops `COALESCE`-shaped counter bumps and
+  empty-`SET` shells; honest `SET col = NULL` writes are captured and
+  render as "Cleared col" on the timeline.
+- **Hot-path performance.** `capture_jobs`, `capture_database`, the
+  excluded-tables / excluded-job-classes / display-name maps, and the
+  user-extended sensitive-key patterns are now memoized at install
+  time across `ActiveJobCapturer`, `DatabaseCapturer`,
+  `BulkDatabaseCapturer`, and `SensitivePatterns`. The
+  `sql.active_record` subscriber is also tuned: 5-arity block to avoid
+  splat allocation, cheap `end_with?` name-prefilter ahead of any
+  parsing, and an early bail before `safe_constantize`. Bulk capture
+  overhead measured below the noise floor on a 10 ms reference query.
+
 ## [0.2.0] — 2026-06-05
 
 ### Added

data/lib/ez_logs_agent/buffer.rb

@@ -59,6 +59,20 @@ module EzLogsAgent
         # Best effort, ignore failures
       end
 
+      # Returns the most recently pushed event WITHOUT removing it.
+      # Used by BulkDatabaseCapturer to backfill the affected-row count
+      # after the relation method's return value is known (Rails'
+      # payload[:row_count] is unreliable for plain DELETE on PG).
+      # Mutating the returned hash in place is intentional and safe —
+      # the event hasn't been flushed yet.
+      # @return [Hash, nil] The last event, or nil if empty.
+      def peek_last
+        @monitor.synchronize { @queue.last }
+      rescue => error
+        log_error("[Buffer] peek_last failed: #{error.message}")
+        nil
+      end
+
       private
 
       def max_size

data/lib/ez_logs_agent/bulk_sql_parser.rb

@@ -63,7 +63,7 @@ module EzLogsAgent
     def parse(sql:, type_casted_binds:)
       return { unparseable: true } if sql.nil? || sql.empty?
 
-      sql_stripped = sql.strip
+      sql_stripped = strip_query_log_tags(sql.strip)
 
       case sql_stripped
       when /\ADELETE FROM /i
@@ -84,6 +84,16 @@ module EzLogsAgent
       { unparseable: true }
     end
 
+    # Strip Rails 7+ Query Log Tags (`/*application='X',action='Y'*/`)
+    # AND any other trailing SQL comments. They land at the end of every
+    # statement when `config.active_record.query_log_tags_enabled = true`
+    # and are pure noise on the timeline — they leak the host app's name
+    # and controller into the user-visible filter line. Removing them at
+    # parse time means we never ship them on the wire.
+    def strip_query_log_tags(sql)
+      sql.gsub(%r{/\*.*?\*/}m, "").rstrip
+    end
+
     # Returns the symbolic operation name we expect downstream. Detected
     # from SQL shape, independent of the `payload[:name]` Rails version
     # variance (see plan §"insert_all/upsert_all payload :name varies").

data/lib/ez_logs_agent/capturers/active_job_capturer.rb

@@ -51,6 +51,25 @@ module EzLogsAgent
         def install
           return unless defined?(ActiveJob)
 
+          # Memoize config values that the per-job hot path reads on
+          # every execute. Without this, capture_execution dispatches
+          # into EzLogsAgent.configuration twice per job (once for
+          # capture_jobs, once for all_excluded_job_classes). On
+          # job-heavy apps that's measurable. Runtime mutations need
+          # uninstall! + install.
+          @capture_enabled =
+            begin
+              EzLogsAgent.configuration.capture_jobs
+            rescue StandardError
+              false
+            end
+          @excluded_job_classes =
+            begin
+              EzLogsAgent.configuration.all_excluded_job_classes.dup.freeze
+            rescue StandardError
+              [].freeze
+            end
+
           install_serialization_hooks unless @serialization_installed
 
           ActiveJob::Base.before_enqueue do |job|
@@ -101,7 +120,11 @@ module EzLogsAgent
         # @param block [Proc] The job execution block
         # @return [Object] The result of the job execution
         def capture_execution(job, block)
-          return block.call unless EzLogsAgent.configuration.capture_jobs
+          # Memoized at install time for hot-path perf. If we haven't
+          # installed yet (specs that test capture_execution directly),
+          # fall back to a live config read so the behavior matches.
+          enabled = defined?(@capture_enabled) ? @capture_enabled : EzLogsAgent.configuration.capture_jobs
+          return block.call unless enabled
 
           if sidekiq_adapter?(job)
             EzLogsAgent::Logger.debug("[ActiveJobCapturer] Skipping capture (Sidekiq adapter)")
@@ -196,8 +219,10 @@ module EzLogsAgent
         # @param job [ActiveJob::Base] The job instance
         # @return [Boolean] true if excluded, false otherwise
         def excluded_job_class?(job)
-          job_class_name = job.class.name
-          EzLogsAgent.configuration.all_excluded_job_classes.include?(job_class_name)
+          # Memoized at install time for perf. Fall back to a live read
+          # for specs that don't call install (see capture_execution).
+          excluded = defined?(@excluded_job_classes) ? @excluded_job_classes : EzLogsAgent.configuration.all_excluded_job_classes
+          excluded.include?(job.class.name)
         rescue StandardError
           false
         end

data/lib/ez_logs_agent/capturers/bulk_database_capturer.rb

@@ -108,16 +108,107 @@ module EzLogsAgent
         def install
           return if @installed
 
-          @subscriber = ::ActiveSupport::Notifications.subscribe("sql.active_record") do |*args|
-            payload = args.last
-            event_name = args.first
-            started = args[1]
-            finished = args[2]
-            handle_notification(event_name, started, finished, payload)
+          # Cache configuration values that the hot path checks per
+          # notification. Re-read on every install (specs reinstall
+          # after toggling config). Runtime mutations to these settings
+          # require uninstall! + install to take effect — acceptable
+          # because nobody flips this at runtime in production.
+          @capture_enabled =
+            begin
+              ::EzLogsAgent.configuration.capture_database
+            rescue StandardError
+              false
+            end
+          @excluded_tables =
+            begin
+              ::EzLogsAgent.configuration.all_excluded_tables.dup.freeze
+            rescue StandardError
+              [].freeze
+            end
+
+          install_row_count_capture!
+
+          # 5-arity block bypasses the `*args` splat allocation per
+          # notification — measurable on hot paths where we ignore
+          # ~99% of events. Block accepts positional args matching the
+          # AS::N convention: (name, start, finish, id, payload).
+          @subscriber = ::ActiveSupport::Notifications.subscribe("sql.active_record") do |name, started, finished, _id, payload|
+            handle_notification(name, started, finished, payload)
           end
           @installed = true
         end
 
+        # Patches ActiveRecord::Relation's bulk methods to backfill the
+        # affected-row count on the most recently captured bulk_database
+        # event. See the comment on RelationRowCountStash below for why
+        # this is necessary (Rails' payload[:row_count] is unreliable
+        # for plain DELETE/UPDATE on PG).
+        def install_row_count_capture!
+          return if @relation_patched
+          return unless defined?(::ActiveRecord::Relation)
+
+          ::ActiveRecord::Relation.prepend(RelationRowCountStash)
+          @relation_patched = true
+        rescue StandardError => e
+          # Patching is best-effort — if AR's Relation isn't there or the
+          # prepend raises, the capturer still works with payload[:row_count].
+          ::EzLogsAgent::Logger.debug("[BulkDatabaseCapturer] could not patch Relation: #{e.class}: #{e.message}")
+        end
+
+        # Patches the row_count on the most recently buffered bulk_database
+        # event when its model matches `model_class`. Called from the
+        # RelationRowCountStash module immediately after `super` returns
+        # from delete_all / update_all. The buffer's `peek_last` API is
+        # the lightweight read path; we mutate in place because the
+        # event hash hasn't been serialized yet.
+        def backfill_row_count(real_count, model_class)
+          return if real_count.nil?
+
+          tail = ::EzLogsAgent::Buffer.peek_last
+          return unless tail.is_a?(Hash)
+          return unless tail[:source_type] == "bulk_database"
+          return unless tail.dig(:source_data, :model_class) == model_class.name
+
+          tail[:source_data][:row_count] = real_count
+          if (rids = tail[:resource_ids]).is_a?(Array) && rids.first.is_a?(Hash)
+            rids.first[:resource_id] = "bulk:#{real_count}"
+          end
+        rescue StandardError => e
+          ::EzLogsAgent::Logger.debug("[BulkDatabaseCapturer] backfill_row_count failed: #{e.class}: #{e.message}")
+        end
+      end
+
+      # Backfills the affected-row count on the most recently captured
+      # bulk_database event. Order of operations:
+      #
+      #   1. Customer calls Relation#delete_all (or update_all).
+      #   2. AR runs the SQL → sql.active_record fires → our AS::N
+      #      handler captures the event with row_count=payload[:row_count]
+      #      (often 0 on PG for plain DELETE).
+      #   3. delete_all's super returns the affected count to us.
+      #   4. We patch the most-recently-buffered bulk_database event's
+      #      source_data[:row_count] AND its sentinel resource_id so the
+      #      timeline shows the real number.
+      #
+      # This is a thin shim — only the count is touched, never the SQL,
+      # context, or wire shape. If the buffer's tail isn't a bulk_database
+      # event for our model (e.g. AS::N skipped it), we leave it alone.
+      module RelationRowCountStash
+        def delete_all
+          result = super
+          ::EzLogsAgent::Capturers::BulkDatabaseCapturer.backfill_row_count(result, klass) if result.is_a?(Integer)
+          result
+        end
+
+        def update_all(*args, **kwargs, &block)
+          result = super
+          ::EzLogsAgent::Capturers::BulkDatabaseCapturer.backfill_row_count(result, klass) if result.is_a?(Integer)
+          result
+        end
+      end
+
+      class << self
+
         # Removes the subscription. Specs use this between examples to
         # avoid leaked subscribers; production never calls it.
         def uninstall!
@@ -132,8 +223,22 @@ module EzLogsAgent
         # tools listening on the same channel. Hard rule: bulk capture failures
         # never propagate.
         def handle_notification(_event_name, started, finished, payload)
-          return unless capture_enabled?
-          return unless eligible_payload?(payload)
+          # Hot path: this runs once per SQL statement in the host app —
+          # often thousands of times per second on a busy tenant. EVERY
+          # branch above the cheapest filter has to be fast. Order is:
+          #
+          #   1. Cheapest possible name check (string suffix, no regex,
+          #      no method dispatch on the configuration object). This
+          #      rejects ~99% of notifications in <1 µs.
+          #   2. Then capture_enabled? (config check).
+          #   3. Then everything else.
+          # Cheapest possible early-exit: a single instance-variable
+          # read. This branch fires on EVERY SQL statement in the host
+          # app and must not allocate or call into configuration.
+          return unless @capture_enabled
+          return unless payload.is_a?(Hash)
+          name = payload[:name]
+          return unless name && name_eligible?(name)
 
           operation = ::EzLogsAgent::BulkSqlParser.detect_operation(payload[:sql])
           return unless operation
@@ -147,6 +252,27 @@ module EzLogsAgent
             type_casted_binds: payload[:type_casted_binds]
           )
 
+          # Drop Rails framework rewrites that aren't real business activity:
+          #
+          #   * Foreign-key nullification — when a parent has `dependent:
+          #     :restrict_with_error` AND the child's `belongs_to :parent`
+          #     is `optional: true`, Rails rewrites `child.delete_all`
+          #     into `UPDATE children SET parent_id = NULL WHERE ...`
+          #     before the destroy. There is no business meaning here;
+          #     it's framework cleanup before the parent goes away.
+          #
+          #   * Counter-cache / increment! — `Model.increment_counter(:x)`
+          #     and `record.increment!(:x)` compile to
+          #     `UPDATE ... SET x = COALESCE(x, 0) + N WHERE id = ?`,
+          #     which is Rails plumbing for a numeric counter bump, not
+          #     a user-visible change.
+          #
+          # Both produce high-volume noise on the timeline (see EZLogs's
+          # own dogfood where Company#increment_actions_count! fires
+          # per ingest batch). Filtering at the capturer means they
+          # don't ride the wire at all.
+          return if framework_rewrite?(operation, parse_result)
+
           source_data = build_source_data(
             operation: operation,
             model_class: model_class,
@@ -183,11 +309,21 @@ module EzLogsAgent
         # @return [Boolean]
         def eligible_payload?(payload)
           return false unless payload.is_a?(Hash)
+          name = payload[:name]
+          name.is_a?(String) && name_eligible?(name)
+        end
 
-          name = payload[:name].to_s
-          return false if name.empty?
-
-          BULK_NAME_HINT.match?(name)
+        # Cheapest possible bulk-name check — string `end_with?` calls,
+        # no regex compilation, no method dispatch. Runs on the hot path.
+        # The four shapes we care about (per AR convention):
+        #   "<Model> Delete All", "<Model> Update All",
+        #   "<Model> Insert", "<Model> Upsert"
+        # (Older Rails 7 also used " Bulk Insert" / " Bulk Upsert" — those
+        # still end with "Insert"/"Upsert" so end_with? catches them.)
+        # Per-row CRUD names like "<Model> Create", "<Model> Update",
+        # "<Model> Destroy" fail all four suffix checks and bail in <1 µs.
+        def name_eligible?(name)
+          name.end_with?(" All") || name.end_with?(" Insert") || name.end_with?(" Upsert")
         end
 
         # Looks up the model class from the SQL's table name. Returns nil
@@ -200,9 +336,26 @@ module EzLogsAgent
           table = extract_table_name(sql)
           return nil if table.nil?
 
-          ::ActiveRecord::Base.descendants.find do |klass|
+          # Try the descendants list first — cheap and works in environments
+          # where models are already eager-loaded (production, Sidekiq workers).
+          loaded = ::ActiveRecord::Base.descendants.find do |klass|
             klass.respond_to?(:table_name) && klass.table_name == table && !klass.abstract_class?
           end
+          return loaded if loaded
+
+          # Fallback for development mode and any lazy-autoload path: derive
+          # the model class name from the table name via Rails' inflector
+          # and try to safe_constantize it. ActiveRecord's reflection class
+          # caches it on first call, so subsequent bulk ops on the same
+          # table hit the descendants path above.
+          constant_name = table.to_s.classify
+          klass = constant_name.safe_constantize
+          return klass if klass.is_a?(Class) &&
+                          klass < ::ActiveRecord::Base &&
+                          klass.respond_to?(:table_name) &&
+                          klass.table_name == table
+
+          nil
         rescue StandardError
           nil
         end
@@ -310,11 +463,12 @@ module EzLogsAgent
         end
 
         # Builds the sentinel resource entry. row_count may be nil (Rails
-        # < 7 didn't ship it; some adapters still don't) — fall back to
-        # "bulk" so the entry is non-nil and the server-side
-        # ResourceAggregationStage doesn't drop it.
+        # < 7 didn't ship it; some adapters still don't), and 0 is also
+        # not informative (PG's update_all returns 0 in some paths) —
+        # fall back to "many" so the display reads naturally and the
+        # server-side ResourceAggregationStage doesn't drop it.
         def build_resource_ids(model_class, row_count)
-          count_str = row_count.is_a?(Integer) ? row_count.to_s : "unknown"
+          count_str = (row_count.is_a?(Integer) && row_count > 0) ? row_count.to_s : "many"
           [{ resource_type: model_class.name, resource_id: "bulk:#{count_str}" }]
         end
 
@@ -327,15 +481,71 @@ module EzLogsAgent
         end
 
         # Uses DatabaseCapturer's existing all_excluded_tables list — one
-        # config knob, both capturers obey it.
+        # config knob, both capturers obey it. The list is memoized at
+        # install time (`@excluded_tables`) so we don't pay a Hash
+        # method dispatch on every captured event. Customers who change
+        # config at runtime need to call uninstall! + install — the same
+        # constraint that already applies to `capture_database`.
         def table_excluded?(model_class)
           return false unless model_class.respond_to?(:table_name)
 
-          ::EzLogsAgent.configuration.all_excluded_tables.include?(model_class.table_name)
+          @excluded_tables.include?(model_class.table_name)
         rescue StandardError
           false
         end
 
+        # Detects Rails-generated update_all SQL that we can't render
+        # meaningfully OR that is pure framework noise. We are deliberately
+        # narrow here — anything that COULD be a real change a customer
+        # cares about (even SET col = NULL on N rows) we keep.
+        #
+        # Filtered shapes:
+        #
+        #   1. Empty SET hash — the parser couldn't extract any column →
+        #      value pairs (e.g. unquoted column names in raw SQL). The
+        #      captured event would render with no "Set X to Y" detail
+        #      and no humanized filter, just "Updated 26 things" with an
+        #      empty Operation block. That's misleading.
+        #
+        #   2. Counter cache / increment! / decrement! — any SET value is
+        #      a `COALESCE(<col>, 0) + N` expression. Rails uses this
+        #      shape for `increment_counter`, `increment!`,
+        #      `update_counters`. The semantics are "bump a number by N",
+        #      which is plumbing-grade noise: high volume (per-request
+        #      counter bumps fire dozens of times per minute on a busy
+        #      tenant) and zero business meaning to a non-technical
+        #      reader. On the EZLogs server alone these would dominate
+        #      the timeline.
+        #
+        # SET <fk> = NULL on N rows IS captured — even though Rails sometimes
+        # generates it implicitly as cleanup before a destroy, it's also
+        # the shape of a real customer-issued nullification (soft-orphaning,
+        # disassociating tags from an item, etc.), and from the SQL alone
+        # we can't tell the two apart. Showing it honestly is the right call:
+        # the reader sees that N rows had their column X set to NULL.
+        #
+        # @return [Boolean]
+        def framework_rewrite?(operation, parse_result)
+          return false unless operation == :update_all
+          return false unless parse_result.is_a?(Hash)
+
+          set = parse_result[:set]
+
+          # Empty SET hash: parser bailed. Drop — would render as an
+          # empty Operation block.
+          return true if set.is_a?(Hash) && set.empty? && !parse_result[:unparseable]
+
+          return false unless set.is_a?(Hash) && set.any?
+
+          # Counter-cache / increment! — any value contains COALESCE().
+          # Distinct from a deliberate UPDATE because the SET expression
+          # references the column on its own RHS, which no business
+          # update_all ever does.
+          return true if set.values.any? { |v| v.to_s.include?("COALESCE(") }
+
+          false
+        end
+
         # Same formatter as DatabaseCapturer. Keeps Date / Time / BigDecimal
         # from collapsing to "[Object]" when they reach Sanitizer / wire.
         def format_value_for_json(value)

data/lib/ez_logs_agent/capturers/database_capturer.rb

@@ -78,6 +78,33 @@ module EzLogsAgent
           return unless defined?(ActiveRecord::Base)
           return if @installed
 
+          # Memoize config values that the per-row hot path reads on
+          # every callback. Without this, each captured create / update
+          # / destroy pays a method dispatch into the configuration
+          # object (`EzLogsAgent.configuration.capture_database`) plus
+          # an `all_excluded_tables.include?` Hash dispatch. On a request
+          # that touches dozens of rows the overhead is real.
+          # Runtime mutations require uninstall! + install to take effect
+          # (acceptable — nobody flips capture_database at runtime).
+          @capture_enabled =
+            begin
+              EzLogsAgent.configuration.capture_database
+            rescue StandardError
+              false
+            end
+          @excluded_tables =
+            begin
+              EzLogsAgent.configuration.all_excluded_tables.dup.freeze
+            rescue StandardError
+              [].freeze
+            end
+          @display_name_for =
+            begin
+              (EzLogsAgent.configuration.display_name_for || {}).dup.freeze
+            rescue StandardError
+              {}.freeze
+            end
+
           # Only register callbacks once per Ruby process
           unless @callbacks_registered
             ActiveRecord::Base.class_eval do
@@ -137,24 +164,24 @@ module EzLogsAgent
 
         private
 
-        # Checks if database capture is enabled
+        # Checks if database capture is enabled. Reads the memoized
+        # value set at install time (no config-object dispatch on the
+        # hot path).
         #
         # @return [Boolean]
         def capture_enabled?
-          EzLogsAgent.configuration.capture_database
-        rescue StandardError
-          false
+          @capture_enabled
         end
 
-        # Checks if the model's table is in the excluded_tables list
-        # Uses all_excluded_tables which combines defaults with user-configured
+        # Checks if the model's table is in the excluded_tables list.
+        # Reads the memoized list set at install time.
         #
         # @param model [ActiveRecord::Base] The model instance
         # @return [Boolean]
         def table_excluded?(model)
           return false unless model.class.respond_to?(:table_name)
 
-          EzLogsAgent.configuration.all_excluded_tables.include?(model.class.table_name)
+          @excluded_tables.include?(model.class.table_name)
         rescue StandardError
           false
         end
@@ -219,9 +246,8 @@ module EzLogsAgent
         # @param model [ActiveRecord::Base] The model instance
         # @return [String, nil] The display name, or nil if no meaningful name found
         def resolve_display_name(model)
-          # Check for configured custom field
-          display_name_config = EzLogsAgent.configuration.display_name_for || {}
-          custom_field = display_name_config[model.class.name]
+          # Check for configured custom field (memoized list, see install).
+          custom_field = @display_name_for[model.class.name]
 
           if custom_field && model.respond_to?(custom_field)
             value = model.public_send(custom_field)

data/lib/ez_logs_agent/sensitive_patterns.rb

@@ -48,17 +48,35 @@ module EzLogsAgent
       key_lower = key.to_s.downcase
       return true if PATTERNS.any? { |pattern| key_lower.include?(pattern) }
 
-      # Direct configuration access — any raise here propagates to the
-      # rescue below and we fail-closed. Wrapping the access in its own
-      # rescue would silently fall back to "no extra patterns" on a
-      # config bug and the outer rescue would never fire, which means
-      # the broken-config path becomes "leak", not "mask".
-      user_patterns = EzLogsAgent.configuration.excluded_graphql_variable_keys || []
-      user_patterns.any? { |pattern| key_lower.include?(pattern.to_s.downcase) }
+      user_patterns = user_patterns_cache
+      user_patterns.any? { |pattern| key_lower.include?(pattern) }
     rescue StandardError
       # Defensive: if configuration access raises, treat as sensitive.
       # Better to over-mask than to leak.
       true
     end
+
+    # Memoized lookup of user-configured patterns, already lowercased.
+    # Called per HTTP param, per DB attribute, per job arg key. Without
+    # the cache it would dispatch into EzLogsAgent.configuration on
+    # every check.
+    #
+    # The cache is keyed by `object_id` of the configured array, so
+    # `EzLogsAgent.configure { |c| c.excluded_graphql_variable_keys = [...] }`
+    # invalidates it naturally (assigning a new array changes its id).
+    # No explicit invalidation needed.
+    def user_patterns_cache
+      configured = EzLogsAgent.configuration.excluded_graphql_variable_keys
+      return @cached_user_patterns if configured.nil? && @cached_source_id.nil?
+
+      source_id = configured&.object_id
+      if source_id != @cached_source_id
+        @cached_user_patterns =
+          (configured || []).map { |p| p.to_s.downcase }.freeze
+        @cached_source_id = source_id
+      end
+      @cached_user_patterns
+    end
+    private_class_method :user_patterns_cache
   end
 end

data/lib/ez_logs_agent/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EzLogsAgent
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ez_logs_agent
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - dezsirazvan