brainzlab 0.1.0

data/lib/brainzlab/recall/client.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module BrainzLab
+  module Recall
+    class Client
+      MAX_RETRIES = 3
+      RETRY_DELAY = 0.5
+
+      def initialize(config)
+        @config = config
+        @uri = URI.parse(config.recall_url)
+      end
+
+      def send_log(log_entry)
+        return unless @config.recall_enabled && @config.valid?
+
+        post("/api/v1/log", log_entry)
+      end
+
+      def send_batch(log_entries)
+        return unless @config.recall_enabled && @config.valid?
+        return if log_entries.empty?
+
+        post("/api/v1/logs", { logs: log_entries })
+      end
+
+      private
+
+      def post(path, body)
+        uri = URI.join(@config.recall_url, path)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{@config.secret_key}"
+        request["User-Agent"] = "brainzlab-sdk-ruby/#{BrainzLab::VERSION}"
+        request.body = JSON.generate(body)
+
+        execute_with_retry(uri, request)
+      rescue StandardError => e
+        log_error("Failed to send to Recall: #{e.message}")
+        nil
+      end
+
+      def execute_with_retry(uri, request)
+        retries = 0
+        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)
+
+          case response.code.to_i
+          when 200..299
+            JSON.parse(response.body) rescue {}
+          when 429, 500..599
+            raise RetryableError, "Server error: #{response.code}"
+          else
+            log_error("Recall API error: #{response.code} - #{response.body}")
+            nil
+          end
+        rescue RetryableError, Net::OpenTimeout, Net::ReadTimeout => e
+          retries += 1
+          if retries <= MAX_RETRIES
+            sleep(RETRY_DELAY * retries)
+            retry
+          end
+          log_error("Failed after #{MAX_RETRIES} retries: #{e.message}")
+          nil
+        end
+      end
+
+      def log_error(message)
+        return unless @config.logger
+
+        @config.logger.error("[BrainzLab] #{message}")
+      end
+
+      class RetryableError < StandardError; end
+    end
+  end
+end

data/lib/brainzlab/recall/logger.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module BrainzLab
+  module Recall
+    class Logger < ::Logger
+      attr_accessor :broadcast_to
+
+      def initialize(service_name = nil, broadcast_to: nil)
+        super(nil)
+        @service_name = service_name
+        @broadcast_to = broadcast_to
+        @level = ::Logger::DEBUG
+        @formatter = proc { |severity, _time, _progname, msg| msg }
+      end
+
+      def add(severity, message = nil, progname = nil, &block)
+        severity ||= ::Logger::UNKNOWN
+
+        # Handle block-based messages
+        if message.nil? && block_given?
+          message = yield
+        end
+
+        # Handle progname as message (standard Logger behavior)
+        if message.nil?
+          message = progname
+          progname = nil
+        end
+
+        # Broadcast to original logger if configured
+        @broadcast_to&.add(severity, message, progname)
+
+        # Skip if below configured level
+        return true if severity < @level
+
+        level = severity_to_level(severity)
+        return true unless BrainzLab.configuration.level_enabled?(level)
+
+        # Extract structured data if message is a hash
+        data = {}
+        if message.is_a?(Hash)
+          data = message.dup
+          message = data.delete(:message) || data.delete(:msg) || data.to_s
+        end
+
+        data[:service] = @service_name if @service_name
+        data[:progname] = progname if progname
+
+        Recall.log(level, message.to_s, **data)
+        true
+      end
+
+      def debug(message = nil, &block)
+        add(::Logger::DEBUG, message, &block)
+      end
+
+      def info(message = nil, &block)
+        add(::Logger::INFO, message, &block)
+      end
+
+      def warn(message = nil, &block)
+        add(::Logger::WARN, message, &block)
+      end
+
+      def error(message = nil, &block)
+        add(::Logger::ERROR, message, &block)
+      end
+
+      def fatal(message = nil, &block)
+        add(::Logger::FATAL, message, &block)
+      end
+
+      def unknown(message = nil, &block)
+        add(::Logger::UNKNOWN, message, &block)
+      end
+
+      # Rails compatibility methods
+      def silence(severity = ::Logger::ERROR)
+        old_level = @level
+        @level = severity
+        yield self
+      ensure
+        @level = old_level
+      end
+
+      def tagged(*tags)
+        if block_given?
+          BrainzLab.with_context(tags: tags) { yield self }
+        else
+          self
+        end
+      end
+
+      def flush
+        Recall.flush
+      end
+
+      def close
+        flush
+      end
+
+      private
+
+      def severity_to_level(severity)
+        case severity
+        when ::Logger::DEBUG then :debug
+        when ::Logger::INFO then :info
+        when ::Logger::WARN then :warn
+        when ::Logger::ERROR then :error
+        when ::Logger::FATAL, ::Logger::UNKNOWN then :fatal
+        else :info
+        end
+      end
+    end
+  end
+end

data/lib/brainzlab/recall/provisioner.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "fileutils"
+
+module BrainzLab
+  module Recall
+    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.recall_auto_provision
+        return false unless @config.app_name.to_s.strip.length > 0
+        return false if @config.secret_key.to_s.strip.length > 0
+        return false unless @config.recall_master_key.to_s.strip.length > 0
+
+        true
+      end
+
+      def provision_project
+        uri = URI.parse("#{@config.recall_url}/api/v1/projects/provision")
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["X-Master-Key"] = @config.recall_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 Recall 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[:ingest_key]
+
+        data
+      rescue StandardError => e
+        log_error("Failed to load cached 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 credentials: #{e.message}")
+      end
+
+      def cache_file_path
+        File.join(CACHE_DIR, "#{@config.app_name}.recall.json")
+      end
+
+      def apply_credentials(project)
+        @config.secret_key = project[:ingest_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] #{message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/recall.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative "recall/client"
+require_relative "recall/buffer"
+require_relative "recall/logger"
+require_relative "recall/provisioner"
+
+module BrainzLab
+  module Recall
+    class << self
+      def debug(message, **data)
+        log(:debug, message, **data)
+      end
+
+      def info(message, **data)
+        log(:info, message, **data)
+      end
+
+      def warn(message, **data)
+        log(:warn, message, **data)
+      end
+
+      def error(message, **data)
+        log(:error, message, **data)
+      end
+
+      def fatal(message, **data)
+        log(:fatal, message, **data)
+      end
+
+      def log(level, message, **data)
+        config = BrainzLab.configuration
+        return unless config.recall_enabled
+
+        # 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
+
+      def ensure_provisioned!
+        return if @provisioned
+
+        @provisioned = true
+        provisioner.ensure_project!
+      end
+
+      def provisioner
+        @provisioner ||= Provisioner.new(BrainzLab.configuration)
+      end
+
+      def time(label, **data)
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result = yield
+        duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(1)
+
+        info("#{label} (#{duration_ms}ms)", **data.merge(duration_ms: duration_ms))
+        result
+      end
+
+      def flush
+        buffer.flush
+      end
+
+      def logger(name = nil)
+        Logger.new(name)
+      end
+
+      def client
+        @client ||= Client.new(BrainzLab.configuration)
+      end
+
+      def buffer
+        @buffer ||= Buffer.new(BrainzLab.configuration, client)
+      end
+
+      def reset!
+        @client = nil
+        @buffer = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def build_entry(level, message, data)
+        config = BrainzLab.configuration
+        context = Context.current
+
+        entry = {
+          timestamp: Time.now.utc.iso8601(3),
+          level: level.to_s,
+          message: message.to_s
+        }
+
+        # Add configuration context
+        entry[:environment] = config.environment if config.environment
+        entry[:service] = config.service if config.service
+        entry[:host] = config.host if config.host
+        entry[:commit] = config.commit if config.commit
+        entry[:branch] = config.branch if config.branch
+
+        # Add request context
+        entry[:request_id] = context.request_id if context.request_id
+        entry[:session_id] = context.session_id if context.session_id
+
+        # Merge context data with provided data
+        merged_data = context.data_hash.merge(scrub_data(data))
+        entry[:data] = merged_data unless merged_data.empty?
+
+        entry
+      end
+
+      def scrub_data(data)
+        return data if BrainzLab.configuration.scrub_fields.empty?
+
+        scrub_fields = BrainzLab.configuration.scrub_fields
+        deep_scrub(data, scrub_fields)
+      end
+
+      def deep_scrub(obj, fields)
+        case obj
+        when Hash
+          obj.each_with_object({}) do |(key, value), result|
+            if should_scrub?(key, fields)
+              result[key] = "[FILTERED]"
+            else
+              result[key] = deep_scrub(value, fields)
+            end
+          end
+        when Array
+          obj.map { |item| deep_scrub(item, fields) }
+        else
+          obj
+        end
+      end
+
+      def should_scrub?(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
+    end
+  end
+end

data/lib/brainzlab/reflex/breadcrumbs.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Reflex
+    class Breadcrumbs
+      MAX_BREADCRUMBS = 50
+
+      def initialize
+        @breadcrumbs = []
+        @mutex = Mutex.new
+      end
+
+      def add(message:, category: "default", level: :info, data: nil)
+        crumb = {
+          timestamp: Time.now.utc.iso8601(3),
+          message: message.to_s,
+          category: category.to_s,
+          level: level.to_s
+        }
+        crumb[:data] = data if data
+
+        @mutex.synchronize do
+          @breadcrumbs << crumb
+          @breadcrumbs.shift if @breadcrumbs.size > MAX_BREADCRUMBS
+        end
+      end
+
+      def to_a
+        @mutex.synchronize { @breadcrumbs.dup }
+      end
+
+      def clear!
+        @mutex.synchronize { @breadcrumbs.clear }
+      end
+
+      def size
+        @mutex.synchronize { @breadcrumbs.size }
+      end
+    end
+
+    class << self
+      def breadcrumbs
+        Context.current.breadcrumbs
+      end
+
+      def add_breadcrumb(message, category: "default", level: :info, data: nil)
+        breadcrumbs.add(message: message, category: category, level: level, data: data)
+      end
+
+      def clear_breadcrumbs!
+        breadcrumbs.clear!
+      end
+    end
+  end
+end

data/lib/brainzlab/reflex/client.rb

@@ -0,0 +1,85 @@
+# 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)
+        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)
+      rescue StandardError => e
+        log_error("Failed to send to Reflex: #{e.message}")
+        nil
+      end
+
+      def execute_with_retry(uri, request)
+        retries = 0
+        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)
+
+          case response.code.to_i
+          when 200..299
+            JSON.parse(response.body) rescue {}
+          when 429, 500..599
+            raise RetryableError, "Server error: #{response.code}"
+          else
+            log_error("Reflex API error: #{response.code} - #{response.body}")
+            nil
+          end
+        rescue RetryableError, Net::OpenTimeout, Net::ReadTimeout => e
+          retries += 1
+          if retries <= MAX_RETRIES
+            sleep(RETRY_DELAY * retries)
+            retry
+          end
+          log_error("Failed after #{MAX_RETRIES} retries: #{e.message}")
+          nil
+        end
+      end
+
+      def log_error(message)
+        return unless @config.logger
+
+        @config.logger.error("[BrainzLab::Reflex] #{message}")
+      end
+
+      class RetryableError < StandardError; end
+    end
+  end
+end