brainzlab 0.1.1 → 0.1.2

data/lib/brainzlab/configuration.rb

@@ -37,6 +37,70 @@ module BrainzLab
                   :pulse_flush_interval,
                   :pulse_sample_rate,
                   :pulse_excluded_paths,
+                  :flux_enabled,
+                  :flux_url,
+                  :flux_api_key,
+                  :flux_ingest_key,
+                  :flux_master_key,
+                  :flux_auto_provision,
+                  :flux_buffer_size,
+                  :flux_flush_interval,
+                  :signal_enabled,
+                  :signal_url,
+                  :signal_api_key,
+                  :signal_master_key,
+                  :signal_auto_provision,
+                  :vault_enabled,
+                  :vault_url,
+                  :vault_api_key,
+                  :vault_master_key,
+                  :vault_auto_provision,
+                  :vault_cache_enabled,
+                  :vault_cache_ttl,
+                  :vault_auto_load,
+                  :vault_load_provider_keys,
+                  :vision_enabled,
+                  :vision_url,
+                  :vision_api_key,
+                  :vision_ingest_key,
+                  :vision_master_key,
+                  :vision_auto_provision,
+                  :vision_default_model,
+                  :vision_default_browser_provider,
+                  :cortex_enabled,
+                  :cortex_url,
+                  :cortex_api_key,
+                  :cortex_master_key,
+                  :cortex_auto_provision,
+                  :cortex_cache_enabled,
+                  :cortex_cache_ttl,
+                  :cortex_default_context,
+                  :beacon_enabled,
+                  :beacon_url,
+                  :beacon_api_key,
+                  :beacon_master_key,
+                  :beacon_auto_provision,
+                  :nerve_enabled,
+                  :nerve_url,
+                  :nerve_api_key,
+                  :nerve_master_key,
+                  :nerve_auto_provision,
+                  :dendrite_enabled,
+                  :dendrite_url,
+                  :dendrite_api_key,
+                  :dendrite_master_key,
+                  :dendrite_auto_provision,
+                  :sentinel_enabled,
+                  :sentinel_url,
+                  :sentinel_api_key,
+                  :sentinel_agent_key,
+                  :sentinel_master_key,
+                  :sentinel_auto_provision,
+                  :synapse_enabled,
+                  :synapse_url,
+                  :synapse_api_key,
+                  :synapse_master_key,
+                  :synapse_auto_provision,
                   :scrub_fields,
                   :logger,
                   :instrument_http,
@@ -49,13 +113,39 @@ module BrainzLab
                   :instrument_action_mailer,
                   :instrument_delayed_job,
                   :instrument_grape,
+                  :instrument_solid_queue,
+                  :instrument_good_job,
+                  :instrument_resque,
+                  :instrument_excon,
+                  :instrument_typhoeus,
+                  :instrument_dalli,
+                  :instrument_aws,
+                  :instrument_stripe,
                   :http_ignore_hosts,
                   :redis_ignore_commands,
                   :log_formatter_enabled,
                   :log_formatter_colors,
                   :log_formatter_hide_assets,
                   :log_formatter_compact_assets,
-                  :log_formatter_show_params
+                  :log_formatter_show_params,
+                  :disable_self_tracking,
+                  :devtools_enabled,
+                  :devtools_error_page_enabled,
+                  :devtools_debug_panel_enabled,
+                  :devtools_allowed_environments,
+                  :devtools_allowed_ips,
+                  :devtools_asset_path,
+                  :devtools_panel_position,
+                  :devtools_expand_by_default
+
+    # Services that should not track themselves to avoid circular dependencies
+    SELF_TRACKING_SERVICES = {
+      "recall" => :recall_enabled,
+      "reflex" => :reflex_enabled,
+      "pulse" => :pulse_enabled,
+      "flux" => :flux_enabled,
+      "signal" => :signal_enabled
+    }.freeze
 
     def initialize
       # Authentication
@@ -76,6 +166,10 @@ module BrainzLab
       # Debug mode - enables verbose logging
       @debug = ENV["BRAINZLAB_DEBUG"] == "true"
 
+      # Disable self-tracking - prevents services from tracking to themselves
+      # e.g., Recall won't log to itself, Reflex won't track errors to itself
+      @disable_self_tracking = ENV.fetch("BRAINZLAB_DISABLE_SELF_TRACKING", "true") == "true"
+
       # Recall settings
       @recall_enabled = true
       @recall_url = ENV["RECALL_URL"] || "https://recall.brainzlab.ai"
@@ -107,6 +201,90 @@ module BrainzLab
       @pulse_sample_rate = nil
       @pulse_excluded_paths = %w[/health /ping /up /assets]
 
+      # Flux settings
+      @flux_enabled = true
+      @flux_url = ENV["FLUX_URL"] || "https://flux.brainzlab.ai"
+      @flux_api_key = ENV["FLUX_API_KEY"]
+      @flux_ingest_key = ENV["FLUX_INGEST_KEY"]
+      @flux_master_key = ENV["FLUX_MASTER_KEY"]
+      @flux_auto_provision = true
+      @flux_buffer_size = 100
+      @flux_flush_interval = 5
+
+      # Signal settings
+      @signal_enabled = true
+      @signal_url = ENV["SIGNAL_URL"] || "https://signal.brainzlab.ai"
+      @signal_api_key = ENV["SIGNAL_API_KEY"]
+      @signal_master_key = ENV["SIGNAL_MASTER_KEY"]
+      @signal_auto_provision = true
+
+      # Vault settings
+      @vault_enabled = true
+      @vault_url = ENV["VAULT_URL"] || "https://vault.brainzlab.ai"
+      @vault_api_key = ENV["VAULT_API_KEY"]
+      @vault_master_key = ENV["VAULT_MASTER_KEY"]
+      @vault_auto_provision = true
+      @vault_cache_enabled = true
+      @vault_cache_ttl = 300  # 5 minutes
+      @vault_auto_load = ENV.fetch("VAULT_AUTO_LOAD", "false") == "true"  # Auto-load secrets into ENV
+      @vault_load_provider_keys = true  # Also load provider keys (OpenAI, etc.)
+
+      # Vision settings (AI browser automation)
+      @vision_enabled = true
+      @vision_url = ENV["VISION_URL"] || "https://vision.brainzlab.ai"
+      @vision_api_key = ENV["VISION_API_KEY"]
+      @vision_ingest_key = ENV["VISION_INGEST_KEY"]
+      @vision_master_key = ENV["VISION_MASTER_KEY"]
+      @vision_auto_provision = true
+      @vision_default_model = ENV["VISION_DEFAULT_MODEL"] || "claude-sonnet-4"
+      @vision_default_browser_provider = ENV["VISION_DEFAULT_BROWSER_PROVIDER"] || "local"
+
+      # Cortex settings (feature flags)
+      @cortex_enabled = true
+      @cortex_url = ENV["CORTEX_URL"] || "https://cortex.brainzlab.ai"
+      @cortex_api_key = ENV["CORTEX_API_KEY"]
+      @cortex_master_key = ENV["CORTEX_MASTER_KEY"]
+      @cortex_auto_provision = true
+      @cortex_cache_enabled = true
+      @cortex_cache_ttl = 60  # 1 minute
+      @cortex_default_context = {}
+
+      # Beacon settings (uptime monitoring)
+      @beacon_enabled = true
+      @beacon_url = ENV["BEACON_URL"] || "https://beacon.brainzlab.ai"
+      @beacon_api_key = ENV["BEACON_API_KEY"]
+      @beacon_master_key = ENV["BEACON_MASTER_KEY"]
+      @beacon_auto_provision = true
+
+      # Nerve settings (job monitoring)
+      @nerve_enabled = true
+      @nerve_url = ENV["NERVE_URL"] || "https://nerve.brainzlab.ai"
+      @nerve_api_key = ENV["NERVE_API_KEY"]
+      @nerve_master_key = ENV["NERVE_MASTER_KEY"]
+      @nerve_auto_provision = true
+
+      # Dendrite settings (AI documentation)
+      @dendrite_enabled = true
+      @dendrite_url = ENV["DENDRITE_URL"] || "https://dendrite.brainzlab.ai"
+      @dendrite_api_key = ENV["DENDRITE_API_KEY"]
+      @dendrite_master_key = ENV["DENDRITE_MASTER_KEY"]
+      @dendrite_auto_provision = true
+
+      # Sentinel settings (host monitoring)
+      @sentinel_enabled = true
+      @sentinel_url = ENV["SENTINEL_URL"] || "https://sentinel.brainzlab.ai"
+      @sentinel_api_key = ENV["SENTINEL_API_KEY"]
+      @sentinel_agent_key = ENV["SENTINEL_AGENT_KEY"]
+      @sentinel_master_key = ENV["SENTINEL_MASTER_KEY"]
+      @sentinel_auto_provision = true
+
+      # Synapse settings (AI development orchestration)
+      @synapse_enabled = true
+      @synapse_url = ENV["SYNAPSE_URL"] || "https://synapse.brainzlab.ai"
+      @synapse_api_key = ENV["SYNAPSE_API_KEY"]
+      @synapse_master_key = ENV["SYNAPSE_MASTER_KEY"]
+      @synapse_auto_provision = true
+
       # Filtering
       @scrub_fields = %i[password password_confirmation token api_key secret]
 
@@ -124,6 +302,14 @@ module BrainzLab
       @instrument_action_mailer = true  # ActionMailer instrumentation
       @instrument_delayed_job = true  # Delayed::Job instrumentation
       @instrument_grape = true  # Grape API instrumentation
+      @instrument_solid_queue = true  # Solid Queue job instrumentation
+      @instrument_good_job = true  # GoodJob instrumentation
+      @instrument_resque = true  # Resque instrumentation
+      @instrument_excon = true  # Excon HTTP client instrumentation
+      @instrument_typhoeus = true  # Typhoeus HTTP client instrumentation
+      @instrument_dalli = true  # Dalli/Memcached instrumentation
+      @instrument_aws = true  # AWS SDK instrumentation
+      @instrument_stripe = true  # Stripe API instrumentation
       @http_ignore_hosts = %w[localhost 127.0.0.1]
       @redis_ignore_commands = %w[ping info]  # Commands to skip tracking
 
@@ -133,6 +319,16 @@ module BrainzLab
       @log_formatter_hide_assets = false
       @log_formatter_compact_assets = true
       @log_formatter_show_params = true
+
+      # DevTools settings (development error page and debug panel)
+      @devtools_enabled = true
+      @devtools_error_page_enabled = true
+      @devtools_debug_panel_enabled = true
+      @devtools_allowed_environments = %w[development test]
+      @devtools_allowed_ips = ["127.0.0.1", "::1", "172.16.0.0/12", "192.168.0.0/16", "10.0.0.0/8"]
+      @devtools_asset_path = "/__brainzlab__"
+      @devtools_panel_position = "bottom-right"
+      @devtools_expand_by_default = false
     end
 
     def recall_min_level=(level)
@@ -168,10 +364,150 @@ module BrainzLab
       pulse_api_key || secret_key
     end
 
+    def flux_valid?
+      key = flux_ingest_key || flux_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def flux_auth_key
+      flux_ingest_key || flux_api_key || secret_key
+    end
+
+    def signal_valid?
+      key = signal_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def signal_auth_key
+      signal_api_key || secret_key
+    end
+
+    def vault_valid?
+      key = vault_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def vault_auth_key
+      vault_api_key || secret_key
+    end
+
+    def vision_valid?
+      key = vision_ingest_key || vision_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def vision_auth_key
+      vision_ingest_key || vision_api_key || secret_key
+    end
+
+    def beacon_valid?
+      key = beacon_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def beacon_auth_key
+      beacon_api_key || secret_key
+    end
+
+    def nerve_valid?
+      key = nerve_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def nerve_auth_key
+      nerve_api_key || secret_key
+    end
+
+    def cortex_valid?
+      key = cortex_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def cortex_auth_key
+      cortex_api_key || secret_key
+    end
+
+    def dendrite_valid?
+      key = dendrite_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def dendrite_auth_key
+      dendrite_api_key || secret_key
+    end
+
+    def sentinel_valid?
+      key = sentinel_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def sentinel_auth_key
+      sentinel_api_key || secret_key
+    end
+
+    def synapse_valid?
+      key = synapse_api_key || secret_key
+      !key.nil? && !key.empty?
+    end
+
+    def synapse_auth_key
+      synapse_api_key || secret_key
+    end
+
     def debug?
       @debug == true
     end
 
+    # Check if recall is effectively enabled (considering self-tracking)
+    def recall_effectively_enabled?
+      return false unless @recall_enabled
+      return true unless @disable_self_tracking
+
+      # Disable if this is the Recall service itself
+      normalized_app_name = @app_name.to_s.downcase.strip
+      normalized_app_name != "recall"
+    end
+
+    # Check if reflex is effectively enabled (considering self-tracking)
+    def reflex_effectively_enabled?
+      return false unless @reflex_enabled
+      return true unless @disable_self_tracking
+
+      # Disable if this is the Reflex service itself
+      normalized_app_name = @app_name.to_s.downcase.strip
+      normalized_app_name != "reflex"
+    end
+
+    # Check if pulse is effectively enabled (considering self-tracking)
+    def pulse_effectively_enabled?
+      return false unless @pulse_enabled
+      return true unless @disable_self_tracking
+
+      # Disable if this is the Pulse service itself
+      normalized_app_name = @app_name.to_s.downcase.strip
+      normalized_app_name != "pulse"
+    end
+
+    # Check if flux is effectively enabled (considering self-tracking)
+    def flux_effectively_enabled?
+      return false unless @flux_enabled
+      return true unless @disable_self_tracking
+
+      # Disable if this is the Flux service itself
+      normalized_app_name = @app_name.to_s.downcase.strip
+      normalized_app_name != "flux"
+    end
+
+    # Check if signal is effectively enabled (considering self-tracking)
+    def signal_effectively_enabled?
+      return false unless @signal_enabled
+      return true unless @disable_self_tracking
+
+      # Disable if this is the Signal service itself
+      normalized_app_name = @app_name.to_s.downcase.strip
+      normalized_app_name != "signal"
+    end
+
     def debug_log(message)
       return unless debug?
 
@@ -201,13 +537,15 @@ module BrainzLab
     end
 
     def detect_git_commit
-      `git rev-parse HEAD 2>/dev/null`.strip.presence
+      result = `git rev-parse HEAD 2>/dev/null`.strip
+      result.empty? ? nil : result
     rescue StandardError
       nil
     end
 
     def detect_git_branch
-      `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip.presence
+      result = `git rev-parse --abbrev-ref HEAD 2>/dev/null`.strip
+      result.empty? ? nil : result
     rescue StandardError
       nil
     end

data/lib/brainzlab/cortex/cache.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Cortex
+    class Cache
+      def initialize(ttl = 60)
+        @ttl = ttl
+        @store = {}
+        @timestamps = {}
+        @mutex = Mutex.new
+      end
+
+      def get(key)
+        @mutex.synchronize do
+          return nil unless @store.key?(key)
+          return nil if expired?(key)
+
+          @store[key]
+        end
+      end
+
+      def set(key, value)
+        @mutex.synchronize do
+          @store[key] = value
+          @timestamps[key] = Time.now
+        end
+      end
+
+      def has?(key)
+        @mutex.synchronize do
+          @store.key?(key) && !expired?(key)
+        end
+      end
+
+      def delete(key)
+        @mutex.synchronize do
+          @store.delete(key)
+          @timestamps.delete(key)
+        end
+      end
+
+      def clear!
+        @mutex.synchronize do
+          @store.clear
+          @timestamps.clear
+        end
+      end
+
+      private
+
+      def expired?(key)
+        timestamp = @timestamps[key]
+        return true unless timestamp
+
+        Time.now - timestamp > @ttl
+      end
+    end
+  end
+end

data/lib/brainzlab/cortex/client.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "cgi"
+
+module BrainzLab
+  module Cortex
+    class Client
+      def initialize(config)
+        @config = config
+        @base_url = config.cortex_url || "https://cortex.brainzlab.ai"
+      end
+
+      # Evaluate a single flag
+      def evaluate(flag_name, context: {})
+        response = request(
+          :post,
+          "/api/v1/evaluate",
+          body: {
+            flag: flag_name,
+            context: context
+          }
+        )
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:result]
+      rescue StandardError => e
+        log_error("evaluate", e)
+        nil
+      end
+
+      # Evaluate multiple flags at once
+      def evaluate_all(context: {})
+        response = request(
+          :post,
+          "/api/v1/evaluate/batch",
+          body: { context: context }
+        )
+
+        return {} unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:flags] || {}
+      rescue StandardError => e
+        log_error("evaluate_all", e)
+        {}
+      end
+
+      # List all flags
+      def list
+        response = request(:get, "/api/v1/flags")
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:flags] || []
+      rescue StandardError => e
+        log_error("list", e)
+        []
+      end
+
+      # Get flag details
+      def get_flag(flag_name)
+        response = request(:get, "/api/v1/flags/#{CGI.escape(flag_name.to_s)}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_flag", e)
+        nil
+      end
+
+      def provision(project_id:, app_name:)
+        response = request(
+          :post,
+          "/api/v1/projects/provision",
+          body: { project_id: project_id, app_name: app_name },
+          use_service_key: true
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+      rescue StandardError => e
+        log_error("provision", e)
+        false
+      end
+
+      private
+
+      def request(method, path, headers: {}, body: nil, params: nil, use_service_key: false)
+        uri = URI.parse("#{@base_url}#{path}")
+
+        if params
+          uri.query = URI.encode_www_form(params)
+        end
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 5
+        http.read_timeout = 10
+
+        request = case method
+        when :get
+          Net::HTTP::Get.new(uri)
+        when :post
+          Net::HTTP::Post.new(uri)
+        when :put
+          Net::HTTP::Put.new(uri)
+        when :delete
+          Net::HTTP::Delete.new(uri)
+        end
+
+        # Set headers
+        request["Content-Type"] = "application/json"
+        request["Accept"] = "application/json"
+
+        if use_service_key
+          request["X-Service-Key"] = @config.cortex_master_key || @config.secret_key
+        else
+          auth_key = @config.cortex_api_key || @config.secret_key
+          request["Authorization"] = "Bearer #{auth_key}" if auth_key
+        end
+
+        headers.each { |k, v| request[k] = v }
+
+        # Set body
+        request.body = body.to_json if body
+
+        http.request(request)
+      end
+
+      def log_error(operation, error)
+        BrainzLab.debug_log("[Cortex::Client] #{operation} failed: #{error.message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/cortex/provisioner.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Cortex
+    class Provisioner
+      def initialize(config)
+        @config = config
+        @provisioned = false
+      end
+
+      def ensure_project!
+        return if @provisioned
+        return unless @config.cortex_auto_provision
+        return unless valid_auth?
+
+        @provisioned = true
+
+        # Try to provision with Platform project ID
+        project_id = detect_project_id
+        return unless project_id
+
+        client = Client.new(@config)
+        client.provision(
+          project_id: project_id,
+          app_name: @config.app_name || @config.service
+        )
+
+        BrainzLab.debug_log("[Cortex::Provisioner] Project provisioned: #{project_id}")
+      rescue StandardError => e
+        BrainzLab.debug_log("[Cortex::Provisioner] Provisioning failed: #{e.message}")
+      end
+
+      private
+
+      def valid_auth?
+        key = @config.cortex_api_key || @config.cortex_master_key || @config.secret_key
+        !key.nil? && !key.empty?
+      end
+
+      def detect_project_id
+        # Try environment variable first
+        return ENV["BRAINZLAB_PROJECT_ID"] if ENV["BRAINZLAB_PROJECT_ID"]
+
+        # Could also detect from Platform API if we have a secret key
+        nil
+      end
+    end
+  end
+end