fluyenta-ruby 0.1.14

data/lib/brainzlab/reflex/client.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+
+module BrainzLab
+  module Reflex
+    class Client
+      MAX_RETRIES = 3
+      RETRY_DELAY = 0.5
+
+      def initialize(config)
+        @config = config
+      end
+
+      def send_error(payload)
+        return unless @config.reflex_enabled && @config.reflex_valid?
+
+        post('/api/v1/errors', payload)
+      end
+
+      def send_batch(payloads)
+        return unless @config.reflex_enabled && @config.reflex_valid?
+        return if payloads.empty?
+
+        post('/api/v1/errors/batch', { errors: payloads })
+      end
+
+      private
+
+      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, path)
+      rescue StandardError => e
+        handle_error(e, context: { path: path, body_size: body.to_s.length })
+        nil
+      end
+
+      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'
+          http.open_timeout = 5
+          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
+            begin
+              JSON.parse(response.body)
+            rescue StandardError
+              {}
+            end
+          when 429, 500..599
+            raise RetryableError, "Server error: #{response.code}"
+          else
+            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
+          retries += 1
+          if retries <= MAX_RETRIES
+            sleep(RETRY_DELAY * retries)
+            retry
+          end
+          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}")
+      end
+
+      class RetryableError < StandardError; end
+    end
+  end
+end

data/lib/brainzlab/reflex/provisioner.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'fileutils'
+
+module BrainzLab
+  module Reflex
+    class Provisioner
+      CACHE_DIR = ENV.fetch('BRAINZLAB_CACHE_DIR') { File.join(Dir.home, '.brainzlab') }
+
+      def initialize(config)
+        @config = config
+      end
+
+      def ensure_project!
+        return unless should_provision?
+
+        # Try cached credentials first
+        if (cached = load_cached_credentials)
+          apply_credentials(cached)
+          return cached
+        end
+
+        # Provision new project
+        project = provision_project
+        return unless project
+
+        # Cache and apply credentials
+        cache_credentials(project)
+        apply_credentials(project)
+
+        project
+      end
+
+      private
+
+      def should_provision?
+        return false unless @config.reflex_auto_provision
+        return false unless @config.app_name.to_s.strip.length.positive?
+        # Only skip if reflex_api_key is already set (not secret_key, which may be for Recall)
+        return false if @config.reflex_api_key.to_s.strip.length.positive?
+        return false unless @config.reflex_master_key.to_s.strip.length.positive?
+
+        true
+      end
+
+      def provision_project
+        uri = URI.parse("#{@config.reflex_url}/api/v1/projects/provision")
+        request = Net::HTTP::Post.new(uri)
+        request['Content-Type'] = 'application/json'
+        request['X-Master-Key'] = @config.reflex_master_key
+        request['User-Agent'] = "brainzlab-sdk-ruby/#{BrainzLab::VERSION}"
+        request.body = JSON.generate({ name: @config.app_name })
+
+        response = execute(uri, request)
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("Failed to provision Reflex project: #{e.message}")
+        nil
+      end
+
+      def load_cached_credentials
+        path = cache_file_path
+        return nil unless File.exist?(path)
+
+        data = JSON.parse(File.read(path), symbolize_names: true)
+
+        # Validate cached data has required keys
+        return nil unless data[:api_key]
+
+        data
+      rescue StandardError => e
+        log_error("Failed to load cached Reflex credentials: #{e.message}")
+        nil
+      end
+
+      def cache_credentials(project)
+        FileUtils.mkdir_p(CACHE_DIR)
+        File.write(cache_file_path, JSON.generate(project))
+      rescue StandardError => e
+        log_error("Failed to cache Reflex credentials: #{e.message}")
+      end
+
+      def cache_file_path
+        File.join(CACHE_DIR, "#{@config.app_name}.reflex.json")
+      end
+
+      def apply_credentials(project)
+        # Use reflex_api_key for Reflex if we have a separate key
+        # Otherwise fall back to shared secret_key
+        @config.reflex_api_key = project[:api_key]
+
+        # Also set service name from app_name if not already set
+        @config.service ||= @config.app_name
+      end
+
+      def execute(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 5
+        http.read_timeout = 10
+        http.request(request)
+      end
+
+      def log_error(message)
+        return unless @config.logger
+
+        @config.logger.error("[BrainzLab::Reflex] #{message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/reflex.rb

@@ -0,0 +1,421 @@
+# frozen_string_literal: true
+
+require_relative 'reflex/client'
+require_relative 'reflex/breadcrumbs'
+require_relative 'reflex/provisioner'
+
+module BrainzLab
+  module Reflex
+    FILTERED_PARAMS = %w[password password_confirmation token api_key secret credit_card cvv ssn].freeze
+
+    class << self
+      def capture(exception, **context)
+        return unless enabled?
+        return if capture_disabled?
+        return if excluded?(exception)
+        return if sampled_out?
+
+        # 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
+
+      def capture_message(message, level: :error, **context)
+        return unless enabled?
+        return if capture_disabled?
+        return if sampled_out?
+
+        # 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
+
+      def ensure_provisioned!
+        return if @provisioned
+
+        @provisioned = true
+        provisioner.ensure_project!
+      end
+
+      def provisioner
+        @provisioner ||= Provisioner.new(BrainzLab.configuration)
+      end
+
+      # Temporarily disable capture within a block
+      def without_capture
+        previous = Thread.current[:brainzlab_capture_disabled]
+        Thread.current[:brainzlab_capture_disabled] = true
+        yield
+      ensure
+        Thread.current[:brainzlab_capture_disabled] = previous
+      end
+
+      def client
+        @client ||= Client.new(BrainzLab.configuration)
+      end
+
+      def reset!
+        @client = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.reflex_effectively_enabled?
+      end
+
+      def capture_disabled?
+        Thread.current[:brainzlab_capture_disabled] == true
+      end
+
+      def excluded?(exception)
+        config = BrainzLab.configuration
+        config.reflex_excluded_exceptions.any? do |excluded|
+          case excluded
+          when String
+            exception.class.name == excluded || exception.class.to_s == excluded
+          when Class
+            exception.is_a?(excluded)
+          when Regexp
+            exception.class.name =~ excluded
+          else
+            false
+          end
+        end
+      end
+
+      def sampled_out?
+        rate = BrainzLab.configuration.reflex_sample_rate
+        return false if rate.nil? || rate >= 1.0
+
+        rand > rate
+      end
+
+      def run_before_send(payload, exception)
+        hook = BrainzLab.configuration.reflex_before_send
+        return payload unless hook
+
+        hook.call(payload, exception)
+      end
+
+      def build_payload(exception, context)
+        config = BrainzLab.configuration
+        ctx = Context.current
+
+        payload = {
+          timestamp: Time.now.utc.iso8601(3),
+          error_class: exception.class.name,
+          message: exception.message,
+          backtrace: format_backtrace(exception.backtrace || []),
+
+          # Environment
+          environment: config.environment,
+          commit: config.commit,
+          branch: config.branch,
+          server_name: config.host,
+
+          # Request context
+          request_id: ctx.request_id
+        }
+
+        # Add request info if available
+        add_request_info(payload, ctx)
+
+        # Add user info
+        add_user_info(payload, ctx, context)
+
+        # Add context, tags, extra
+        add_context_data(payload, ctx, context)
+
+        # Add breadcrumbs
+        payload[:breadcrumbs] = ctx.breadcrumbs.to_a
+
+        # Add fingerprint for error grouping
+        payload[:fingerprint] = compute_fingerprint(exception, context, ctx)
+
+        payload
+      end
+
+      def build_message_payload(message, level, context)
+        config = BrainzLab.configuration
+        ctx = Context.current
+
+        payload = {
+          timestamp: Time.now.utc.iso8601(3),
+          error_class: 'Message',
+          message: message.to_s,
+          level: level.to_s,
+
+          # Environment
+          environment: config.environment,
+          commit: config.commit,
+          branch: config.branch,
+          server_name: config.host,
+
+          # Request context
+          request_id: ctx.request_id
+        }
+
+        # Add request info if available
+        add_request_info(payload, ctx)
+
+        # Add user info
+        add_user_info(payload, ctx, context)
+
+        # Add context, tags, extra
+        add_context_data(payload, ctx, context)
+
+        # Add breadcrumbs
+        payload[:breadcrumbs] = ctx.breadcrumbs.to_a
+
+        payload
+      end
+
+      def add_request_info(payload, ctx)
+        return unless ctx.request_path
+
+        payload[:request] = {
+          method: ctx.request_method,
+          path: ctx.request_path,
+          url: ctx.request_url,
+          params: filter_params(ctx.request_params),
+          headers: ctx.request_headers,
+          controller: ctx.controller,
+          action: ctx.action
+        }.compact
+      end
+
+      def add_user_info(payload, ctx, context)
+        user = context[:user] || ctx.user
+        return if user.nil? || user.empty?
+
+        payload[:user] = {
+          id: user[:id]&.to_s,
+          email: user[:email],
+          name: user[:name]
+        }.compact
+
+        # Store additional user data
+        extra_user = user.except(:id, :email, :name)
+        payload[:user_data] = extra_user unless extra_user.empty?
+      end
+
+      def add_context_data(payload, ctx, context)
+        # Tags from context + provided tags
+        tags = ctx.tags.merge(context[:tags] || {})
+        payload[:tags] = tags unless tags.empty?
+
+        # Extra data from context + provided extra
+        extra = ctx.data_hash.merge(context[:extra] || {})
+        extra = extra.except(:user, :tags) # Remove user and tags as they're separate
+        payload[:extra] = extra unless extra.empty?
+
+        # General context
+        payload[:context] = context.except(:user, :tags, :extra) unless context.except(:user, :tags, :extra).empty?
+      end
+
+      def format_backtrace(backtrace)
+        backtrace.first(30).map do |line|
+          if line.is_a?(String)
+            parse_backtrace_line(line)
+          else
+            line
+          end
+        end
+      end
+
+      def parse_backtrace_line(line)
+        # Parse various Ruby backtrace formats:
+        # - "path/to/file.rb:42:in `method_name'"  (backtick + single quote)
+        # - "path/to/file.rb:42:in 'method_name'"  (single quotes)
+        # - "path/to/file.rb:42"                   (no method)
+        if line =~ /\A(.+):(\d+):in [`']([^']+)'?\z/
+          {
+            file: ::Regexp.last_match(1),
+            line: ::Regexp.last_match(2).to_i,
+            function: ::Regexp.last_match(3),
+            in_app: in_app_frame?(::Regexp.last_match(1))
+          }
+        elsif line =~ /\A(.+):(\d+)\z/
+          {
+            file: ::Regexp.last_match(1),
+            line: ::Regexp.last_match(2).to_i,
+            function: nil,
+            in_app: in_app_frame?(::Regexp.last_match(1))
+          }
+        else
+          # Still store file for display even if format is unexpected
+          { file: line, line: nil, function: nil, in_app: false }
+        end
+      end
+
+      def in_app_frame?(path)
+        return false if path.nil?
+        return false if path.include?('vendor/')
+        return false if path.include?('/gems/')
+        return false if path.include?('/ruby/')
+
+        # Match both relative and absolute paths containing app/ or lib/
+        path.start_with?('app/', 'lib/', './app/', './lib/') ||
+          path.include?('/app/') ||
+          path.include?('/lib/')
+      end
+
+      def filter_params(params)
+        return nil if params.nil?
+
+        scrub_fields = BrainzLab.configuration.scrub_fields + FILTERED_PARAMS.map(&:to_sym)
+        deep_filter(params, scrub_fields)
+      end
+
+      def deep_filter(obj, fields)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(key, value), result|
+            result[key] = if should_filter?(key, fields)
+                            '[FILTERED]'
+                          else
+                            deep_filter(value, fields)
+                          end
+          end
+        when Array
+          obj.map { |item| deep_filter(item, fields) }
+        else
+          obj
+        end
+      end
+
+      def should_filter?(key, fields)
+        key_str = key.to_s.downcase
+        fields.any? do |field|
+          case field
+          when Regexp
+            key_str.match?(field)
+          else
+            key_str == field.to_s.downcase
+          end
+        end
+      end
+
+      # Compute fingerprint for error grouping
+      # Returns an array of strings that uniquely identify the error type
+      def compute_fingerprint(exception, context, ctx)
+        custom_callback = BrainzLab.configuration.reflex_fingerprint
+
+        if custom_callback
+          # Call user's custom fingerprint callback
+          result = custom_callback.call(exception, context, ctx)
+
+          # Normalize the result
+          case result
+          when Array
+            result.map(&:to_s)
+          when String
+            [result]
+          when nil
+            # nil means use default fingerprinting
+            default_fingerprint(exception)
+          else
+            [result.to_s]
+          end
+        else
+          default_fingerprint(exception)
+        end
+      rescue StandardError => e
+        BrainzLab.debug_log("Custom fingerprint callback failed: #{e.message}")
+        default_fingerprint(exception)
+      end
+
+      # Default fingerprint: error class + first in-app frame (or first frame)
+      def default_fingerprint(exception)
+        parts = [exception.class.name]
+
+        if exception.backtrace&.any?
+          # Try to find the first in-app frame
+          in_app_frame = exception.backtrace.find { |line| in_app_line?(line) }
+          frame = in_app_frame || exception.backtrace.first
+
+          if frame
+            # Normalize the frame (remove line numbers for consistent grouping)
+            normalized = normalize_frame_for_fingerprint(frame)
+            parts << normalized if normalized
+          end
+        end
+
+        parts
+      end
+
+      def in_app_line?(line)
+        return false if line.nil?
+        return false if line.include?('vendor/')
+        return false if line.include?('/gems/')
+
+        line.start_with?('app/', 'lib/', './app/', './lib/') ||
+          line.include?('/app/') ||
+          line.include?('/lib/')
+      end
+
+      def normalize_frame_for_fingerprint(frame)
+        return nil unless frame.is_a?(String)
+
+        # Extract file and method, normalize out line numbers
+        # "app/models/user.rb:42:in `save'" -> "app/models/user.rb:in `save'"
+        if frame =~ /\A(.+):\d+:in `(.+)'\z/
+          "#{::Regexp.last_match(1)}:in `#{::Regexp.last_match(2)}'"
+        elsif frame =~ /\A(.+):\d+\z/
+          ::Regexp.last_match(1)
+        else
+          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