brainzlab 0.1.33 → 0.1.35

data/lib/brainzlab/instrumentation/active_record.rb

@@ -31,6 +31,36 @@ module BrainzLab
           BrainzLab.debug_log('ActiveRecord instrumentation installed (sql, instantiation, transactions, strict_loading)')
         end
 
+        # Capture the execution plan for a query slow enough to be worth one.
+        #
+        # Runs here, in the app, because Pulse never has access to the app's
+        # database — a plan can only be produced on this side of the wire. The
+        # plan travels with the span so the backend can point at a sequential
+        # scan instead of guessing from normalized SQL.
+        #
+        # @param payload [Hash] the sql.active_record payload
+        # @param duration [Numeric] query duration in ms
+        # @return [String, nil] the plan, or nil when not captured
+        def explain_plan_for(payload, duration)
+          config = BrainzLab.configuration
+          return nil unless config.pulse_explain_enabled
+          return nil if duration < config.pulse_explain_threshold
+          return nil if payload[:cached] # never reached the database
+
+          connection = payload[:connection]
+          return nil if connection.nil?
+
+          result = BrainzLab::Pulse::ExplainCapture.capture(
+            sql: payload[:sql],
+            connection: connection,
+            timeout: config.pulse_explain_timeout
+          )
+          result && result[:plan]
+        rescue StandardError => e
+          BrainzLab.debug_log("Explain plan capture failed: #{e.message}")
+          nil
+        end
+
         def installed?
           @installed == true
         end
@@ -50,7 +80,6 @@ module BrainzLab
         end
 
         def handle_sql_event(event)
-          payload = event.payload
           duration = event.duration.round(2)
 
           # Record breadcrumb for Reflex (enhanced)
@@ -134,7 +163,8 @@ module BrainzLab
               'db.cached' => payload[:cached] || false,
               'db.async' => payload[:async] || false,
               'db.row_count' => payload[:row_count],
-              'db.affected_rows' => payload[:affected_rows]
+              'db.affected_rows' => payload[:affected_rows],
+              'db.explain_plan' => explain_plan_for(payload, duration)
             }.compact
           }
 
@@ -187,14 +217,12 @@ module BrainzLab
           tracker[:count] += 1
 
           # Store sample queries (limited)
-          if tracker[:queries].size < 3
-            tracker[:queries] << truncate_sql(sql, 200)
-          end
+          tracker[:queries] << truncate_sql(sql, 200) if tracker[:queries].size < 3
 
           # Detect N+1 pattern
-          if tracker[:count] == BrainzLab.configuration.n_plus_one_threshold
-            report_n_plus_one(table, tracker)
-          end
+          return unless tracker[:count] == BrainzLab.configuration.n_plus_one_threshold
+
+          report_n_plus_one(table, tracker)
         end
 
         def report_n_plus_one(table, tracker)
@@ -209,14 +237,14 @@ module BrainzLab
             }
           )
 
-          if BrainzLab.configuration.recall_effectively_enabled?
-            BrainzLab::Recall.warn(
-              "Potential N+1 query detected",
-              table: table,
-              query_count: tracker[:count],
-              sample_queries: tracker[:queries]
-            )
-          end
+          return unless BrainzLab.configuration.recall_effectively_enabled?
+
+          BrainzLab::Recall.warn(
+            'Potential N+1 query detected',
+            table: table,
+            query_count: tracker[:count],
+            sample_queries: tracker[:queries]
+          )
         end
 
         def clear_n_plus_one_tracker!
@@ -301,8 +329,8 @@ module BrainzLab
           transaction = event.payload[:transaction]
           return unless transaction
 
-          Thread.current[:brainzlab_transaction_starts] ||= {}
-          Thread.current[:brainzlab_transaction_starts][transaction.object_id] = event.time
+          Thread.current[:brainzlab_transaction_starts] ||= {}.compare_by_identity
+          Thread.current[:brainzlab_transaction_starts][transaction] = event.time
         rescue StandardError => e
           BrainzLab.debug_log("ActiveRecord transaction start instrumentation failed: #{e.message}")
         end
@@ -313,8 +341,8 @@ module BrainzLab
           outcome = payload[:outcome] # :commit, :rollback, :restart, :incomplete
 
           # Calculate duration from stored start time
-          starts = Thread.current[:brainzlab_transaction_starts] || {}
-          start_time = starts.delete(transaction&.object_id) || event.time
+          starts = Thread.current[:brainzlab_transaction_starts] || {}.compare_by_identity
+          start_time = starts.delete(transaction) || event.time
           duration = ((event.end - start_time) * 1000).round(2)
 
           connection_name = extract_connection_name(payload[:connection])
@@ -409,7 +437,7 @@ module BrainzLab
           # Log to Recall
           if BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.warn(
-              "Strict loading violation detected",
+              'Strict loading violation detected',
               owner_class: owner_class,
               association: association_name.to_s,
               message: "Attempted to lazily load #{association_name} on #{owner_class} with strict_loading enabled"
@@ -454,7 +482,7 @@ module BrainzLab
           # Log to Recall
           if BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.warn(
-              "Deprecated association accessed",
+              'Deprecated association accessed',
               owner_class: owner_class,
               association: association_name.to_s,
               message: message
@@ -490,9 +518,9 @@ module BrainzLab
           # Handles: SELECT ... FROM table_name, SELECT ... FROM "table_name", etc.
           return nil unless sql =~ /\ASELECT/i
 
-          if sql =~ /FROM\s+["'`]?(\w+)["'`]?/i
-            ::Regexp.last_match(1)
-          end
+          return unless sql =~ /FROM\s+["'`]?(\w+)["'`]?/i
+
+          ::Regexp.last_match(1)
         end
 
         def skip_query?(payload)

data/lib/brainzlab/instrumentation/active_storage.rb

@@ -145,7 +145,7 @@ module BrainzLab
 
           key = payload[:key]
           service = payload[:service]
-          checksum = payload[:checksum]
+          payload[:checksum]
 
           # Record breadcrumb
           if BrainzLab.configuration.reflex_effectively_enabled?
@@ -294,7 +294,7 @@ module BrainzLab
           # Log to Recall - bulk deletes are significant
           if BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.info(
-              "Storage bulk delete by prefix",
+              'Storage bulk delete by prefix',
               prefix: truncate_key(prefix),
               service: service,
               duration_ms: duration
@@ -357,7 +357,7 @@ module BrainzLab
           # Log slow URL generations
           if duration >= 50 && BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.warn(
-              "Slow storage URL generation",
+              'Slow storage URL generation',
               key: truncate_key(key),
               service: service,
               duration_ms: duration
@@ -411,7 +411,7 @@ module BrainzLab
           key = payload[:key]
           service = payload[:service]
           content_type = payload[:content_type]
-          disposition = payload[:disposition]
+          payload[:disposition]
 
           # Record breadcrumb
           if BrainzLab.configuration.reflex_effectively_enabled?

data/lib/brainzlab/instrumentation/active_support_cache.rb

@@ -109,7 +109,7 @@ module BrainzLab
                 hit_count: hit_count,
                 miss_count: key_count - hit_count,
                 duration_ms: duration,
-                hit_rate: key_count > 0 ? (hit_count.to_f / key_count * 100).round(1) : 0
+                hit_rate: key_count.positive? ? (hit_count.to_f / key_count * 100).round(1) : 0
               }
             )
           end
@@ -476,7 +476,7 @@ module BrainzLab
           # Log pattern deletes
           if BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.info(
-              "Cache pattern delete",
+              'Cache pattern delete',
               pattern: truncate_key(key),
               duration_ms: duration
             )
@@ -502,7 +502,6 @@ module BrainzLab
           duration = event.duration.round(2)
 
           size = payload[:size]
-          key = payload[:key]
 
           # Record breadcrumb
           if BrainzLab.configuration.reflex_effectively_enabled?
@@ -539,7 +538,6 @@ module BrainzLab
           payload = event.payload
           duration = event.duration.round(2)
 
-          key = payload[:key]
           from = payload[:from]
           to = payload[:to]
 
@@ -563,7 +561,7 @@ module BrainzLab
           # Log prune operations
           if BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.info(
-              "Cache pruned",
+              'Cache pruned',
               from: from,
               to: to,
               duration_ms: duration
@@ -593,8 +591,8 @@ module BrainzLab
 
           serializer = payload[:serializer]
           fallback = payload[:fallback]
-          serialized = payload[:serialized]
-          deserialized = payload[:deserialized]
+          payload[:serialized]
+          payload[:deserialized]
 
           # Record breadcrumb - this is a warning as it indicates a format mismatch
           if BrainzLab.configuration.reflex_effectively_enabled?
@@ -613,7 +611,7 @@ module BrainzLab
           # Log to Recall - this is significant for debugging serialization issues
           if BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.warn(
-              "Message serializer fallback used",
+              'Message serializer fallback used',
               serializer: serializer.to_s,
               fallback: fallback.to_s,
               duration_ms: duration

data/lib/brainzlab/instrumentation/aws.rb

@@ -15,13 +15,16 @@ module BrainzLab
         private
 
         def install_plugin!
-          # AWS SDK v3 uses plugins
-          if defined?(::Aws::Plugins)
-            ::Aws.config[:plugins] ||= []
-            ::Aws.config[:plugins] << BrainzLabPlugin unless ::Aws.config[:plugins].include?(BrainzLabPlugin)
-          end
-
-          # Also hook into Seahorse for lower-level tracking
+          # Registered through Seahorse only. Every AWS client inherits from
+          # Seahorse::Client::Base, so this one hook covers S3, SQS and the rest,
+          # on every version of the SDK.
+          #
+          # There used to be a second registration through Aws.config[:plugins].
+          # That option only exists on newer aws-sdk-core; on older ones it does
+          # not degrade, it makes *every* client fail to construct with
+          # "invalid configuration option :plugins" — so an app pinned to an
+          # older SDK could not talk to S3 at all. It bought nothing either way,
+          # since the handler below is the same handler.
           return unless defined?(::Seahorse::Client::Base)
 
           install_seahorse_handler!

data/lib/brainzlab/instrumentation/grape.rb

@@ -25,6 +25,26 @@ module BrainzLab
           @installed = false
         end
 
+        # Resolve the route pattern to name a trace by.
+        #
+        # Grape exposes the matched pattern (/users/:id) via routing_args, and
+        # that is always preferred. When it does not, naming the trace after the
+        # raw path turns every record into its own endpoint — /users/1,
+        # /users/2, ... — so the path is normalized first, using the routing
+        # args as param hints when they are present.
+        #
+        # @param env [Hash] the Rack env
+        # @param path [String, nil] the concrete request path
+        # @return [String, nil] a pattern safe to aggregate on
+        def route_pattern_for(env, path)
+          routing_args = safe_routing_args(env)
+          pattern = routing_args && safe_dig(routing_args, :route_info)&.pattern&.path
+          return pattern if pattern
+
+          params = routing_args.is_a?(Hash) ? routing_args.reject { |k, _| k.to_sym == :route_info } : nil
+          BrainzLab::Utilities::RoutePathNormalizer.normalize(path, params)
+        end
+
         private
 
         def install_notifications!
@@ -176,6 +196,20 @@ module BrainzLab
           }
         end
 
+        def safe_routing_args(env)
+          env.is_a?(Hash) ? env['grape.routing_args'] : nil
+        rescue StandardError
+          nil
+        end
+
+        def safe_dig(routing_args, key)
+          return nil unless routing_args.respond_to?(:dig)
+
+          routing_args[key]
+        rescue StandardError
+          nil
+        end
+
         def extract_route_pattern(endpoint)
           return '/' unless endpoint
 
@@ -242,8 +276,9 @@ module BrainzLab
           method = request.request_method
           path = request.path
 
-          # Get route pattern from Grape if available
-          route_pattern = env['grape.routing_args']&.dig(:route_info)&.pattern&.path || path
+          # Get route pattern from Grape if available, else normalize the raw
+          # path so /users/1 and /users/2 aggregate as one endpoint.
+          route_pattern = route_pattern_for(env, path)
 
           spans = Thread.current[:brainzlab_pulse_spans] || []
 

data/lib/brainzlab/instrumentation/rails_deprecation.rb

@@ -60,7 +60,7 @@ module BrainzLab
           # Log to Recall for tracking
           if BrainzLab.configuration.recall_effectively_enabled?
             BrainzLab::Recall.warn(
-              "Rails deprecation warning",
+              'Rails deprecation warning',
               message: truncate_message(message, 500),
               gem_name: gem_name,
               deprecation_horizon: deprecation_horizon,

data/lib/brainzlab/instrumentation/railties.rb

@@ -4,8 +4,8 @@ module BrainzLab
   module Instrumentation
     class Railties
       # Thresholds for slow initializers (in milliseconds)
-      SLOW_INITIALIZER_THRESHOLD = 100   # 100ms
-      VERY_SLOW_INITIALIZER_THRESHOLD = 500  # 500ms
+      SLOW_INITIALIZER_THRESHOLD = 100 # 100ms
+      VERY_SLOW_INITIALIZER_THRESHOLD = 500 # 500ms
 
       class << self
         def install!

data/lib/brainzlab/nerve/client.rb

@@ -212,9 +212,9 @@ module BrainzLab
         BrainzLab.debug_log("[Nerve::Client] #{operation} failed: #{structured_error.message}")
 
         # Call on_error callback if configured
-        if @config.on_error
-          @config.on_error.call(structured_error, { service: 'Nerve', operation: operation })
-        end
+        return unless @config.on_error
+
+        @config.on_error.call(structured_error, { service: 'Nerve', operation: operation })
       end
 
       def handle_response_error(response, operation)
@@ -224,9 +224,7 @@ module BrainzLab
         BrainzLab.debug_log("[Nerve::Client] #{operation} failed: #{structured_error.message}")
 
         # Call on_error callback if configured
-        if @config.on_error
-          @config.on_error.call(structured_error, { service: 'Nerve', operation: operation })
-        end
+        @config.on_error&.call(structured_error, { service: 'Nerve', operation: operation })
 
         structured_error
       end

data/lib/brainzlab/pulse/client.rb

@@ -207,7 +207,7 @@ module BrainzLab
       end
 
       def handle_error(error, context: {})
-        log_error("#{error.message}")
+        log_error(error.message.to_s)
 
         # Call on_error callback if configured
         return unless @config.on_error

data/lib/brainzlab/pulse/explain_capture.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+module BrainzLab
+  module Pulse
+    # Captures a query execution plan from the application's own database
+    # connection and attaches it to the span.
+    #
+    # This runs client-side on purpose: Pulse is an external service and never
+    # has access to a customer's database, so an EXPLAIN can only be produced
+    # here, where the connection already exists. It is what turns "this query
+    # took 340ms" into "this query sequentially scans orders".
+    #
+    # Safety rules, in order of importance:
+    #   * read-only statements only — never explain a write
+    #   * plain EXPLAIN, never EXPLAIN ANALYZE (which executes the statement)
+    #   * a wall-clock timeout, so a slow planner cannot stall a request
+    #   * one EXPLAIN per distinct statement, not per occurrence
+    #   * every failure is swallowed — instrumentation must never break the app
+    module ExplainCapture
+      DEFAULT_TIMEOUT = 2 # seconds
+      # Bounds the memory held by the "already explained" set on an app with
+      # heavily varied SQL.
+      MAX_CACHED_STATEMENTS = 500
+
+      # Guards against the EXPLAIN itself emitting a sql.active_record event
+      # that feeds straight back into capture.
+      IN_FLIGHT_KEY = :brainzlab_explain_in_flight
+
+      READ_ONLY_START = /\A\s*(?:SELECT|WITH)\b/i
+      # Any statement separator followed by more content: a plan-only statement
+      # must be a single query.
+      MULTI_STATEMENT = /;\s*\S/
+
+      class << self
+        # @param sql [String] the statement to explain
+        # @param connection [Object] an ActiveRecord-like connection
+        # @param timeout [Integer] seconds to wait for the plan
+        # @return [Hash, nil] { plan:, adapter: } or nil when not captured
+        def capture(sql:, connection:, timeout: DEFAULT_TIMEOUT)
+          return nil if Thread.current[IN_FLIGHT_KEY]
+          return nil unless explainable?(sql)
+          return nil unless connection.respond_to?(:exec_query)
+
+          fingerprint = fingerprint_for(sql)
+          return nil if already_explained?(fingerprint)
+
+          Thread.current[IN_FLIGHT_KEY] = true
+          begin
+            remember(fingerprint)
+            plan = Timeout.timeout(timeout) { run_explain(sql, connection) }
+            return nil if plan.nil? || plan.empty?
+
+            { plan: plan, adapter: adapter_for(connection) }
+          rescue StandardError => e
+            BrainzLab.debug_log("Explain capture failed: #{e.message}")
+            nil
+          ensure
+            Thread.current[IN_FLIGHT_KEY] = nil
+          end
+        end
+
+        # Forget which statements have been explained. Used by the specs and
+        # available to long-lived processes that want to re-sample plans.
+        def reset!
+          mutex.synchronize { explained.clear }
+        end
+
+        private
+
+        def explainable?(sql)
+          return false if sql.nil? || sql.strip.empty?
+          return false unless sql.match?(READ_ONLY_START)
+          return false if sql.match?(MULTI_STATEMENT)
+
+          true
+        end
+
+        def run_explain(sql, connection)
+          result = connection.exec_query("EXPLAIN #{sql}")
+          rows = result.respond_to?(:rows) ? result.rows : result
+          return nil if rows.nil?
+
+          Array(rows).map { |row| Array(row).join(' | ') }.join("\n")
+        end
+
+        def adapter_for(connection)
+          return nil unless connection.respond_to?(:adapter_name)
+
+          connection.adapter_name.to_s.downcase
+        rescue StandardError
+          nil
+        end
+
+        # Collapse whitespace so that the same statement formatted differently
+        # is not explained twice.
+        def fingerprint_for(sql)
+          sql.strip.gsub(/\s+/, ' ')
+        end
+
+        def already_explained?(fingerprint)
+          mutex.synchronize { explained.include?(fingerprint) }
+        end
+
+        def remember(fingerprint)
+          mutex.synchronize do
+            explained.clear if explained.size >= MAX_CACHED_STATEMENTS
+            explained << fingerprint
+          end
+        end
+
+        def explained
+          @explained ||= Set.new
+        end
+
+        def mutex
+          @mutex ||= Mutex.new
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/pulse.rb

@@ -5,6 +5,7 @@ require_relative 'pulse/provisioner'
 require_relative 'pulse/tracer'
 require_relative 'pulse/instrumentation'
 require_relative 'pulse/propagation'
+require_relative 'pulse/explain_capture'
 
 module BrainzLab
   module Pulse
@@ -118,7 +119,11 @@ module BrainzLab
 
         # Parse timestamp or use current time
         started_at = if timestamp
-                       Time.parse(timestamp) rescue Time.now.utc
+                       begin
+                         Time.parse(timestamp)
+                       rescue StandardError
+                         Time.now.utc
+                       end
                      else
                        Time.now.utc
                      end

data/lib/brainzlab/rails/railtie.rb

@@ -33,9 +33,7 @@ module BrainzLab
         # Add request context middleware. Gated on `enabled` so the kill switch
         # (BRAINZLAB_SDK_ENABLED=false) fully removes it — it previously loaded
         # unconditionally, so disabling didn't stop its session interference.
-        if BrainzLab.configuration.enabled
-          app.middleware.insert_after ActionDispatch::RequestId, BrainzLab::Rails::Middleware
-        end
+        app.middleware.insert_after ActionDispatch::RequestId, BrainzLab::Rails::Middleware if BrainzLab.configuration.enabled
 
         # Add DevTools middlewares if enabled
         if BrainzLab.configuration.devtools_enabled

data/lib/brainzlab/reflex/client.rb

@@ -125,7 +125,7 @@ module BrainzLab
       end
 
       def handle_error(error, context: {})
-        log_error("#{error.message}")
+        log_error(error.message.to_s)
 
         # Call on_error callback if configured
         return unless @config.on_error

data/lib/brainzlab/sentinel/client.rb

@@ -213,9 +213,9 @@ module BrainzLab
         BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{structured_error.message}")
 
         # Call on_error callback if configured
-        if @config.on_error
-          @config.on_error.call(structured_error, { service: 'Sentinel', operation: operation })
-        end
+        return unless @config.on_error
+
+        @config.on_error.call(structured_error, { service: 'Sentinel', operation: operation })
       end
 
       def handle_response_error(response, operation)
@@ -225,9 +225,7 @@ module BrainzLab
         BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{structured_error.message}")
 
         # Call on_error callback if configured
-        if @config.on_error
-          @config.on_error.call(structured_error, { service: 'Sentinel', operation: operation })
-        end
+        @config.on_error&.call(structured_error, { service: 'Sentinel', operation: operation })
 
         structured_error
       end

data/lib/brainzlab/signal/client.rb

@@ -11,16 +11,30 @@ module BrainzLab
         @config = config
       end
 
+      # ⚠️ Signal NO expone un endpoint de alta de alertas ad-hoc.
+      # `resources :alerts` es `only: [:index, :show]`, así que este POST
+      # devolvía 404 (verificado contra producción el 2026-10-16). Se enruta a
+      # `alerts#trigger`, que es lo más cercano que existe — pero exige que YA
+      # exista una AlertRule con ese `name` en el proyecto, o responde 404.
+      # Ver company/tasks/signal-alertas-caidas en el OS: reconciliar la API
+      # del SDK con el modelo de Signal es una decisión de producto pendiente.
       def send_alert(alert)
-        post('/api/v1/alerts', alert)
+        post('/api/v1/alerts/trigger', alert)
       end
 
+      # ⚠️ Signal no tiene ninguna ruta `notifications` (grep en su
+      # config/routes.rb: 0 coincidencias). Este POST siempre fue un 404.
+      # No se reenruta a ciegas porque no hay equivalente: entregar a un canal
+      # concreto es otra cosa que disparar una alerta.
       def send_notification(notification)
         post('/api/v1/notifications', notification)
       end
 
+      # Antes posteaba a '/api/v1/rules/trigger', que no existe —
+      # `resources :rules` solo expone los miembros mute/unmute/test.
+      # La ruta real es `post "alerts/trigger" => "alerts#trigger"`.
       def trigger_rule(payload)
-        post('/api/v1/rules/trigger', payload)
+        post('/api/v1/alerts/trigger', payload)
       end
 
       private

data/lib/brainzlab/signal.rb

@@ -72,9 +72,17 @@ module BrainzLab
         ensure_provisioned!
         return unless BrainzLab.configuration.signal_valid?
 
+        # `alerts#trigger` en Signal lee params[:name], params[:value] y
+        # params[:labels] — NO params[:rule] ni params[:context]. Mandar `rule:`
+        # hacía que `find_by!(name: nil)` levantara RecordNotFound → 404, así
+        # que ni con la ruta correcta habría funcionado. Se mantienen las claves
+        # viejas por compatibilidad con cualquier consumidor que las lea.
         payload = {
           type: 'trigger',
+          name: rule_name,
           rule: rule_name,
+          value: context[:value] || context['value'],
+          labels: context,
           context: context,
           timestamp: Time.now.utc.iso8601(3),
           environment: BrainzLab.configuration.environment,

data/lib/brainzlab/synapse/client.rb

@@ -285,9 +285,9 @@ module BrainzLab
         BrainzLab.debug_log("[Synapse::Client] #{operation} failed: #{structured_error.message}")
 
         # Call on_error callback if configured
-        if @config.on_error
-          @config.on_error.call(structured_error, { service: 'Synapse', operation: operation })
-        end
+        return unless @config.on_error
+
+        @config.on_error.call(structured_error, { service: 'Synapse', operation: operation })
       end
 
       def handle_response_error(response, operation)
@@ -297,9 +297,7 @@ module BrainzLab
         BrainzLab.debug_log("[Synapse::Client] #{operation} failed: #{structured_error.message}")
 
         # Call on_error callback if configured
-        if @config.on_error
-          @config.on_error.call(structured_error, { service: 'Synapse', operation: operation })
-        end
+        @config.on_error&.call(structured_error, { service: 'Synapse', operation: operation })
 
         structured_error
       end

data/lib/brainzlab/testing/event_store.rb

@@ -187,9 +187,9 @@ module BrainzLab
       def error_captured?(error_class = nil, message: nil, context: nil)
         @mutex.synchronize do
           @errors.any? do |error|
-            if error_class
-              next false unless error[:error_class] == error_class.to_s ||
-                                (error_class.is_a?(Class) && error[:exception].is_a?(error_class))
+            if error_class && !(error[:error_class] == error_class.to_s ||
+                                (error_class.is_a?(Class) && error[:exception].is_a?(error_class)))
+              next false
             end
 
             if message