brainzlab 0.1.11 → 0.1.20

data/lib/brainzlab/recall.rb

@@ -31,14 +31,24 @@ module BrainzLab
       def log(level, message, **data)
         config = BrainzLab.configuration
         return unless config.recall_effectively_enabled?
+        return unless config.level_enabled?(level)
+
+        entry = build_entry(level, message, data)
+
+        # Log debug output for the operation
+        log_debug_operation(level, message, data)
+
+        # In development mode, log locally instead of sending to server
+        if config.development_mode?
+          Development.record(service: :recall, event_type: 'log', payload: entry)
+          return
+        end
 
         # Auto-provision project on first log if app_name is configured
         ensure_provisioned!
 
-        return unless config.level_enabled?(level)
         return unless config.valid?
 
-        entry = build_entry(level, message, data)
         buffer.push(entry)
       end
 
@@ -153,6 +163,13 @@ module BrainzLab
           end
         end
       end
+
+      def log_debug_operation(level, message, data)
+        return unless BrainzLab::Debug.enabled?
+
+        truncated_message = message.to_s.length > 50 ? "#{message.to_s[0..47]}..." : message.to_s
+        BrainzLab::Debug.log_operation(:recall, "#{level.to_s.upcase} \"#{truncated_message}\"", **data.slice(*data.keys.first(3)))
+      end
     end
   end
 end

data/lib/brainzlab/reflex/client.rb

@@ -31,20 +31,29 @@ module BrainzLab
 
       def post(path, body)
         uri = URI.join(@config.reflex_url, path)
+
+        # Call on_send callback if configured
+        invoke_on_send(:reflex, :post, path, body)
+
+        # Log debug output for request
+        log_debug_request(path, body)
+
         request = Net::HTTP::Post.new(uri)
         request['Content-Type'] = 'application/json'
         request['Authorization'] = "Bearer #{@config.reflex_auth_key}"
         request['User-Agent'] = "brainzlab-sdk-ruby/#{BrainzLab::VERSION}"
         request.body = JSON.generate(body)
 
-        execute_with_retry(uri, request)
+        execute_with_retry(uri, request, path)
       rescue StandardError => e
-        log_error("Failed to send to Reflex: #{e.message}")
+        handle_error(e, context: { path: path, body_size: body.to_s.length })
         nil
       end
 
-      def execute_with_retry(uri, request)
+      def execute_with_retry(uri, request, path)
         retries = 0
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
         begin
           http = Net::HTTP.new(uri.host, uri.port)
           http.use_ssl = uri.scheme == 'https'
@@ -52,6 +61,10 @@ module BrainzLab
           http.read_timeout = 10
 
           response = http.request(request)
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+
+          # Log debug output for response
+          log_debug_response(response.code.to_i, duration_ms)
 
           case response.code.to_i
           when 200..299
@@ -63,7 +76,10 @@ module BrainzLab
           when 429, 500..599
             raise RetryableError, "Server error: #{response.code}"
           else
-            log_error("Reflex API error: #{response.code} - #{response.body}")
+            handle_error(
+              StandardError.new("Reflex API error: #{response.code}"),
+              context: { path: path, status: response.code, body: response.body }
+            )
             nil
           end
         rescue RetryableError, Net::OpenTimeout, Net::ReadTimeout => e
@@ -72,12 +88,57 @@ module BrainzLab
             sleep(RETRY_DELAY * retries)
             retry
           end
-          log_error("Failed after #{MAX_RETRIES} retries: #{e.message}")
+          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round(2)
+          log_debug_response(0, duration_ms, error: e.message)
+          handle_error(e, context: { path: path, retries: retries })
           nil
         end
       end
 
+      def log_debug_request(path, body)
+        return unless BrainzLab::Debug.enabled?
+
+        data = if body.is_a?(Hash) && body[:errors]
+                 { count: body[:errors].size }
+               elsif body.is_a?(Hash) && body[:exception]
+                 { exception: body[:exception][:type] }
+               else
+                 {}
+               end
+
+        BrainzLab::Debug.log_request(:reflex, 'POST', path, data: data)
+      end
+
+      def log_debug_response(status, duration_ms, error: nil)
+        return unless BrainzLab::Debug.enabled?
+
+        BrainzLab::Debug.log_response(:reflex, status, duration_ms, error: error)
+      end
+
+      def invoke_on_send(service, method, path, payload)
+        return unless @config.on_send
+
+        @config.on_send.call(service, method, path, payload)
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_send callback error: #{e.message}")
+      end
+
+      def handle_error(error, context: {})
+        log_error("#{error.message}")
+
+        # Call on_error callback if configured
+        return unless @config.on_error
+
+        @config.on_error.call(error, context.merge(service: :reflex))
+      rescue StandardError => e
+        # Don't let callback errors break the SDK
+        log_error("on_error callback error: #{e.message}")
+      end
+
       def log_error(message)
+        BrainzLab::Debug.log(message, level: :error) if BrainzLab::Debug.enabled?
+
         return unless @config.logger
 
         @config.logger.error("[BrainzLab::Reflex] #{message}")

data/lib/brainzlab/reflex.rb

@@ -15,15 +15,24 @@ module BrainzLab
         return if excluded?(exception)
         return if sampled_out?
 
-        # Auto-provision project on first capture if app_name is configured
-        ensure_provisioned!
-
-        return unless BrainzLab.configuration.reflex_valid?
+        # Log debug output for the operation
+        log_debug_capture(exception)
 
         payload = build_payload(exception, context)
         payload = run_before_send(payload, exception)
         return if payload.nil?
 
+        # In development mode, log locally instead of sending to server
+        if BrainzLab.configuration.development_mode?
+          Development.record(service: :reflex, event_type: 'error', payload: payload)
+          return
+        end
+
+        # Auto-provision project on first capture if app_name is configured
+        ensure_provisioned!
+
+        return unless BrainzLab.configuration.reflex_valid?
+
         client.send_error(payload)
       end
 
@@ -32,15 +41,24 @@ module BrainzLab
         return if capture_disabled?
         return if sampled_out?
 
-        # Auto-provision project on first capture if app_name is configured
-        ensure_provisioned!
-
-        return unless BrainzLab.configuration.reflex_valid?
+        # Log debug output for the operation
+        log_debug_message(message, level)
 
         payload = build_message_payload(message, level, context)
         payload = run_before_send(payload, nil)
         return if payload.nil?
 
+        # In development mode, log locally instead of sending to server
+        if BrainzLab.configuration.development_mode?
+          Development.record(service: :reflex, event_type: 'message', payload: payload)
+          return
+        end
+
+        # Auto-provision project on first capture if app_name is configured
+        ensure_provisioned!
+
+        return unless BrainzLab.configuration.reflex_valid?
+
         client.send_error(payload)
       end
 
@@ -384,6 +402,20 @@ module BrainzLab
           frame
         end
       end
+
+      def log_debug_capture(exception)
+        return unless BrainzLab::Debug.enabled?
+
+        truncated_message = exception.message.to_s.length > 40 ? "#{exception.message.to_s[0..37]}..." : exception.message.to_s
+        BrainzLab::Debug.log_operation(:reflex, "capture #{exception.class.name}: \"#{truncated_message}\"")
+      end
+
+      def log_debug_message(message, level)
+        return unless BrainzLab::Debug.enabled?
+
+        truncated_message = message.to_s.length > 40 ? "#{message.to_s[0..37]}..." : message.to_s
+        BrainzLab::Debug.log_operation(:reflex, "message [#{level.to_s.upcase}] \"#{truncated_message}\"")
+      end
     end
   end
 end

data/lib/brainzlab/sentinel/client.rb

@@ -209,7 +209,27 @@ module BrainzLab
       end
 
       def log_error(operation, error)
-        BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{error.message}")
+        structured_error = ErrorHandler.wrap(error, service: 'Sentinel', operation: operation)
+        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
+      end
+
+      def handle_response_error(response, operation)
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated) || response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPAccepted)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Sentinel', operation: operation)
+        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
+
+        structured_error
       end
     end
   end

data/lib/brainzlab/synapse/client.rb

@@ -281,7 +281,27 @@ module BrainzLab
       end
 
       def log_error(operation, error)
-        BrainzLab.debug_log("[Synapse::Client] #{operation} failed: #{error.message}")
+        structured_error = ErrorHandler.wrap(error, service: 'Synapse', operation: operation)
+        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
+      end
+
+      def handle_response_error(response, operation)
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated) || response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPAccepted)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Synapse', operation: operation)
+        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
+
+        structured_error
       end
     end
   end

data/lib/brainzlab/testing/event_store.rb

@@ -0,0 +1,377 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Testing
+    # Thread-safe store for captured events, logs, errors, and metrics during tests
+    #
+    # This class is used internally by the testing helpers to store all
+    # captured data from stubbed SDK calls.
+    class EventStore
+      def initialize
+        @mutex = Mutex.new
+        @events = []
+        @metrics = []
+        @logs = []
+        @errors = []
+        @error_messages = []
+        @traces = []
+        @alerts = []
+        @notifications = []
+        @triggers = []
+      end
+
+      # === Events (Flux) ===
+
+      def record_event(name, properties = {})
+        @mutex.synchronize do
+          @events << {
+            name: name.to_s,
+            properties: properties,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def events
+        @mutex.synchronize { @events.dup }
+      end
+
+      def events_named(name)
+        @mutex.synchronize do
+          @events.select { |e| e[:name] == name.to_s }
+        end
+      end
+
+      def event_tracked?(name, properties = nil)
+        @mutex.synchronize do
+          @events.any? do |event|
+            next false unless event[:name] == name.to_s
+            next true if properties.nil?
+
+            properties_match?(event[:properties], properties)
+          end
+        end
+      end
+
+      def last_event
+        @mutex.synchronize { @events.last }
+      end
+
+      def clear_events!
+        @mutex.synchronize { @events.clear }
+      end
+
+      # === Metrics (Flux) ===
+
+      def record_metric(type, name, value, opts = {})
+        @mutex.synchronize do
+          @metrics << {
+            type: type.to_sym,
+            name: name.to_s,
+            value: value,
+            tags: opts[:tags] || {},
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def metrics
+        @mutex.synchronize { @metrics.dup }
+      end
+
+      def metrics_named(name)
+        @mutex.synchronize do
+          @metrics.select { |m| m[:name] == name.to_s }
+        end
+      end
+
+      def metric_recorded?(type, name, value: nil, tags: nil)
+        @mutex.synchronize do
+          @metrics.any? do |metric|
+            next false unless metric[:type] == type.to_sym
+            next false unless metric[:name] == name.to_s
+            next false if value && metric[:value] != value
+            next false if tags && !properties_match?(metric[:tags], tags)
+
+            true
+          end
+        end
+      end
+
+      def clear_metrics!
+        @mutex.synchronize { @metrics.clear }
+      end
+
+      # === Logs (Recall) ===
+
+      def record_log(level, message, data = {})
+        @mutex.synchronize do
+          @logs << {
+            level: level.to_sym,
+            message: message.to_s,
+            data: data,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def logs
+        @mutex.synchronize { @logs.dup }
+      end
+
+      def logs_at_level(level)
+        @mutex.synchronize do
+          @logs.select { |l| l[:level] == level.to_sym }
+        end
+      end
+
+      def logged?(level, message = nil, data = nil)
+        @mutex.synchronize do
+          @logs.any? do |log|
+            next false unless log[:level] == level.to_sym
+            next true if message.nil?
+
+            message_matches = case message
+                              when Regexp
+                                log[:message].match?(message)
+                              else
+                                log[:message].include?(message.to_s)
+                              end
+
+            next false unless message_matches
+            next true if data.nil?
+
+            properties_match?(log[:data], data)
+          end
+        end
+      end
+
+      def clear_logs!
+        @mutex.synchronize { @logs.clear }
+      end
+
+      # === Errors (Reflex) ===
+
+      def record_error(exception, context = {})
+        @mutex.synchronize do
+          @errors << {
+            exception: exception,
+            error_class: exception.class.name,
+            message: exception.message,
+            backtrace: exception.backtrace,
+            context: context,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def record_error_message(message, level, context = {})
+        @mutex.synchronize do
+          @error_messages << {
+            message: message.to_s,
+            level: level.to_sym,
+            context: context,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def errors
+        @mutex.synchronize { @errors.dup }
+      end
+
+      def error_messages
+        @mutex.synchronize { @error_messages.dup }
+      end
+
+      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))
+            end
+
+            if message
+              message_matches = case message
+                                when Regexp
+                                  error[:message].match?(message)
+                                else
+                                  error[:message].include?(message.to_s)
+                                end
+              next false unless message_matches
+            end
+
+            next false if context && !properties_match?(error[:context], context)
+
+            true
+          end
+        end
+      end
+
+      def last_error
+        @mutex.synchronize { @errors.last }
+      end
+
+      def clear_errors!
+        @mutex.synchronize do
+          @errors.clear
+          @error_messages.clear
+        end
+      end
+
+      # === Traces (Pulse) ===
+
+      def record_trace(name, opts = {})
+        @mutex.synchronize do
+          @traces << {
+            name: name.to_s,
+            options: opts,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def traces
+        @mutex.synchronize { @traces.dup }
+      end
+
+      def trace_recorded?(name, opts = nil)
+        @mutex.synchronize do
+          @traces.any? do |trace|
+            next false unless trace[:name] == name.to_s
+            next true if opts.nil?
+
+            properties_match?(trace[:options], opts)
+          end
+        end
+      end
+
+      def clear_traces!
+        @mutex.synchronize { @traces.clear }
+      end
+
+      # === Alerts (Signal) ===
+
+      def record_alert(name, message, severity, channels, data)
+        @mutex.synchronize do
+          @alerts << {
+            name: name.to_s,
+            message: message.to_s,
+            severity: severity.to_sym,
+            channels: channels,
+            data: data,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def alerts
+        @mutex.synchronize { @alerts.dup }
+      end
+
+      def alert_sent?(name, message: nil, severity: nil)
+        @mutex.synchronize do
+          @alerts.any? do |alert|
+            next false unless alert[:name] == name.to_s
+            next false if message && !alert[:message].include?(message.to_s)
+            next false if severity && alert[:severity] != severity.to_sym
+
+            true
+          end
+        end
+      end
+
+      def clear_alerts!
+        @mutex.synchronize { @alerts.clear }
+      end
+
+      # === Notifications (Signal) ===
+
+      def record_notification(channel, message, title, data)
+        @mutex.synchronize do
+          @notifications << {
+            channel: Array(channel).map(&:to_s),
+            message: message.to_s,
+            title: title,
+            data: data,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def notifications
+        @mutex.synchronize { @notifications.dup }
+      end
+
+      def clear_notifications!
+        @mutex.synchronize { @notifications.clear }
+      end
+
+      # === Triggers (Signal) ===
+
+      def record_trigger(rule_name, context)
+        @mutex.synchronize do
+          @triggers << {
+            rule_name: rule_name.to_s,
+            context: context,
+            timestamp: Time.now.utc
+          }
+        end
+      end
+
+      def triggers
+        @mutex.synchronize { @triggers.dup }
+      end
+
+      def clear_triggers!
+        @mutex.synchronize { @triggers.clear }
+      end
+
+      # === General ===
+
+      def clear!
+        @mutex.synchronize do
+          @events.clear
+          @metrics.clear
+          @logs.clear
+          @errors.clear
+          @error_messages.clear
+          @traces.clear
+          @alerts.clear
+          @notifications.clear
+          @triggers.clear
+        end
+      end
+
+      def empty?
+        @mutex.synchronize do
+          @events.empty? &&
+            @metrics.empty? &&
+            @logs.empty? &&
+            @errors.empty? &&
+            @error_messages.empty? &&
+            @traces.empty? &&
+            @alerts.empty? &&
+            @notifications.empty? &&
+            @triggers.empty?
+        end
+      end
+
+      private
+
+      def properties_match?(actual, expected)
+        expected.all? do |key, value|
+          actual_value = actual[key] || actual[key.to_s] || actual[key.to_sym]
+
+          case value
+          when Regexp
+            actual_value.to_s.match?(value)
+          else
+            actual_value == value
+          end
+        end
+      end
+    end
+  end
+end