fluyenta-ruby 0.1.14

data/lib/brainzlab/context.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  class Context
+    THREAD_KEY = :brainzlab_context
+
+    class << self
+      def current
+        Thread.current[THREAD_KEY] ||= new
+      end
+
+      def clear!
+        Thread.current[THREAD_KEY] = nil
+      end
+    end
+
+    attr_accessor :user, :request_id, :session_id, :request_method, :request_path, :request_url, :request_params,
+                  :request_headers, :controller, :action
+    attr_reader :extra, :tags, :breadcrumbs
+
+    def initialize
+      @user = {}
+      @extra = {}
+      @tags = {}
+      @request_id = nil
+      @session_id = nil
+      @request_method = nil
+      @request_path = nil
+      @request_url = nil
+      @request_params = nil
+      @request_headers = nil
+      @controller = nil
+      @action = nil
+      @stack = []
+      @breadcrumbs = Reflex::Breadcrumbs.new
+    end
+
+    def set_user(id: nil, email: nil, name: nil, **extra)
+      @user = { id: id, email: email, name: name }.compact.merge(extra)
+    end
+
+    def set_context(**data)
+      @extra.merge!(data)
+    end
+
+    def set_tags(**data)
+      @tags.merge!(data)
+    end
+
+    def with_context(**data)
+      push_context(data)
+      yield
+    ensure
+      pop_context
+    end
+
+    def to_hash
+      result = {}
+      result[:request_id] = @request_id if @request_id
+      result[:session_id] = @session_id if @session_id
+
+      merged_extra = @extra.dup
+      @stack.each { |ctx| merged_extra.merge!(ctx) }
+
+      result[:user] = @user unless @user.empty?
+      result[:tags] = @tags unless @tags.empty?
+      result[:context] = merged_extra unless merged_extra.empty?
+
+      result
+    end
+
+    def data_hash
+      merged = @extra.dup
+      @stack.each { |ctx| merged.merge!(ctx) }
+      merged[:user] = @user unless @user.empty?
+      merged[:tags] = @tags unless @tags.empty?
+      merged
+    end
+
+    private
+
+    def push_context(data)
+      @stack.push(data)
+    end
+
+    def pop_context
+      @stack.pop
+    end
+  end
+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,159 @@
+# 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}")
+
+        uri.query = URI.encode_www_form(params) if params
+
+        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)
+        structured_error = ErrorHandler.wrap(error, service: 'Cortex', operation: operation)
+        BrainzLab.debug_log("[Cortex::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Cortex', 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)
+
+        structured_error = ErrorHandler.from_response(response, service: 'Cortex', operation: operation)
+        BrainzLab.debug_log("[Cortex::Client] #{operation} failed: #{structured_error.message}")
+
+        # Call on_error callback if configured
+        if @config.on_error
+          @config.on_error.call(structured_error, { service: 'Cortex', operation: operation })
+        end
+
+        structured_error
+      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

data/lib/brainzlab/cortex.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative 'cortex/client'
+require_relative 'cortex/cache'
+require_relative 'cortex/provisioner'
+
+module BrainzLab
+  module Cortex
+    class << self
+      # Check if a feature flag is enabled
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context (user, attributes, etc.)
+      # @return [Boolean] True if the flag is enabled
+      #
+      # @example
+      #   if BrainzLab::Cortex.enabled?(:new_checkout, user: current_user)
+      #     render_new_checkout
+      #   end
+      #
+      def enabled?(flag_name, **context)
+        result = get(flag_name, **context)
+        [true, 'true'].include?(result)
+      end
+
+      # Check if a feature flag is disabled
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context
+      # @return [Boolean] True if the flag is disabled
+      def disabled?(flag_name, **context)
+        !enabled?(flag_name, **context)
+      end
+
+      # Get the value of a feature flag
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context
+      # @param default [Object] Default value if flag not found
+      # @return [Object] The flag value
+      #
+      # @example
+      #   limit = BrainzLab::Cortex.get(:rate_limit, user: current_user, default: 100)
+      #
+      def get(flag_name, default: nil, **context)
+        return default unless module_enabled?
+
+        ensure_provisioned!
+        return default unless BrainzLab.configuration.cortex_valid?
+
+        flag_key = flag_name.to_s
+        merged_context = merge_context(context)
+        cache_key = build_cache_key(flag_key, merged_context)
+
+        # Check cache first
+        return cache.get(cache_key) if BrainzLab.configuration.cortex_cache_enabled && cache.has?(cache_key)
+
+        result = client.evaluate(flag_key, context: merged_context)
+
+        if result.nil?
+          default
+        else
+          cache.set(cache_key, result) if BrainzLab.configuration.cortex_cache_enabled
+          result
+        end
+      end
+
+      # Get the variant for an A/B test flag
+      # @param flag_name [String, Symbol] The flag name
+      # @param context [Hash] Evaluation context
+      # @param default [String] Default variant if flag not found
+      # @return [String, nil] The variant name
+      #
+      # @example
+      #   variant = BrainzLab::Cortex.variant(:checkout_experiment, user: current_user)
+      #   case variant
+      #   when "control" then render_control
+      #   when "treatment_a" then render_treatment_a
+      #   when "treatment_b" then render_treatment_b
+      #   end
+      #
+      def variant(flag_name, default: nil, **context)
+        result = get(flag_name, **context)
+        result.is_a?(String) ? result : default
+      end
+
+      # Get all flags for a context
+      # @param context [Hash] Evaluation context
+      # @return [Hash] All flag values
+      #
+      # @example
+      #   flags = BrainzLab::Cortex.all(user: current_user)
+      #   flags[:new_checkout]  # => true
+      #   flags[:rate_limit]    # => 200
+      #
+      def all(**context)
+        return {} unless module_enabled?
+
+        ensure_provisioned!
+        return {} unless BrainzLab.configuration.cortex_valid?
+
+        merged_context = merge_context(context)
+        client.evaluate_all(context: merged_context)
+      end
+
+      # List all flag definitions
+      # @return [Array<Hash>] List of flag metadata
+      def list_flags
+        return [] unless module_enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.cortex_valid?
+
+        client.list
+      end
+
+      # Get a flag's configuration
+      # @param flag_name [String, Symbol] The flag name
+      # @return [Hash, nil] Flag configuration
+      def flag_config(flag_name)
+        return nil unless module_enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.cortex_valid?
+
+        client.get_flag(flag_name.to_s)
+      end
+
+      # Clear the flag cache
+      def clear_cache!
+        cache.clear!
+      end
+
+      # === Context Helpers ===
+
+      # Set default context for all evaluations in current request
+      # @param context [Hash] Context to merge
+      def set_context(**context)
+        Thread.current[:cortex_context] = (Thread.current[:cortex_context] || {}).merge(context)
+      end
+
+      # Clear the current context
+      def clear_context!
+        Thread.current[:cortex_context] = nil
+      end
+
+      # Evaluate flags with a temporary context
+      # @param context [Hash] Temporary context
+      def with_context(**context)
+        previous = Thread.current[:cortex_context]
+        Thread.current[:cortex_context] = (previous || {}).merge(context)
+        yield
+      ensure
+        Thread.current[:cortex_context] = previous
+      end
+
+      # === INTERNAL ===
+
+      def ensure_provisioned!
+        return if @provisioned
+
+        @provisioned = true
+        provisioner.ensure_project!
+      end
+
+      def provisioner
+        @provisioner ||= Provisioner.new(BrainzLab.configuration)
+      end
+
+      def client
+        @client ||= Client.new(BrainzLab.configuration)
+      end
+
+      def cache
+        @cache ||= Cache.new(BrainzLab.configuration.cortex_cache_ttl)
+      end
+
+      def reset!
+        @client = nil
+        @provisioner = nil
+        @cache = nil
+        @provisioned = false
+        Thread.current[:cortex_context] = nil
+      end
+
+      private
+
+      def module_enabled?
+        BrainzLab.configuration.cortex_enabled
+      end
+
+      def merge_context(context)
+        default_context = BrainzLab.configuration.cortex_default_context || {}
+        thread_context = Thread.current[:cortex_context] || {}
+
+        # Also include user from BrainzLab context if available
+        brainzlab_context = {}
+        brainzlab_context[:user] = BrainzLab::Context.current.user if BrainzLab::Context.current.user
+
+        # Normalize user context
+        merged = default_context.merge(brainzlab_context).merge(thread_context).merge(context)
+
+        # Convert user object to hash if needed
+        if merged[:user].respond_to?(:id)
+          merged[:user] = {
+            id: merged[:user].id.to_s,
+            email: merged[:user].try(:email),
+            name: merged[:user].try(:name)
+          }.compact
+        end
+
+        merged
+      end
+
+      def build_cache_key(flag_name, context)
+        # Include relevant context in cache key
+        user_id = context.dig(:user, :id) || context[:user_id]
+        env = BrainzLab.configuration.environment
+
+        parts = [env, flag_name]
+        parts << "u:#{user_id}" if user_id
+        parts.join(':')
+      end
+    end
+  end
+end