brainzlab 0.1.2 → 0.1.4

data/lib/brainzlab/synapse/client.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "json"
-require "uri"
+require 'net/http'
+require 'json'
+require 'uri'
 
 module BrainzLab
   module Synapse
     class Client
       def initialize(config)
         @config = config
-        @base_url = config.synapse_url || "https://synapse.brainzlab.ai"
+        @base_url = config.synapse_url || 'https://synapse.brainzlab.ai'
       end
 
       # List all projects
@@ -17,14 +17,14 @@ module BrainzLab
         params = { page: page, per_page: per_page }
         params[:status] = status if status
 
-        response = request(:get, "/api/v1/projects", params: params)
+        response = request(:get, '/api/v1/projects', params: params)
 
         return [] unless response.is_a?(Net::HTTPSuccess)
 
         data = JSON.parse(response.body, symbolize_names: true)
         data[:projects] || []
       rescue StandardError => e
-        log_error("list_projects", e)
+        log_error('list_projects', e)
         []
       end
 
@@ -36,7 +36,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_project", e)
+        log_error('get_project', e)
         nil
       end
 
@@ -44,7 +44,7 @@ module BrainzLab
       def create_project(name:, repos: [], description: nil, **options)
         response = request(
           :post,
-          "/api/v1/projects",
+          '/api/v1/projects',
           body: {
             name: name,
             description: description,
@@ -57,7 +57,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("create_project", e)
+        log_error('create_project', e)
         nil
       end
 
@@ -66,7 +66,7 @@ module BrainzLab
         response = request(:post, "/api/v1/projects/#{project_id}/up")
         response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
       rescue StandardError => e
-        log_error("start_project", e)
+        log_error('start_project', e)
         false
       end
 
@@ -75,7 +75,7 @@ module BrainzLab
         response = request(:post, "/api/v1/projects/#{project_id}/down")
         response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
       rescue StandardError => e
-        log_error("stop_project", e)
+        log_error('stop_project', e)
         false
       end
 
@@ -84,7 +84,7 @@ module BrainzLab
         response = request(:post, "/api/v1/projects/#{project_id}/restart")
         response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
       rescue StandardError => e
-        log_error("restart_project", e)
+        log_error('restart_project', e)
         false
       end
 
@@ -103,7 +103,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("deploy", e)
+        log_error('deploy', e)
         nil
       end
 
@@ -115,7 +115,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_deployment", e)
+        log_error('get_deployment', e)
         nil
       end
 
@@ -123,7 +123,7 @@ module BrainzLab
       def create_task(project_id:, description:, type: nil, priority: nil, **options)
         response = request(
           :post,
-          "/api/v1/tasks",
+          '/api/v1/tasks',
           body: {
             project_id: project_id,
             description: description,
@@ -137,7 +137,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("create_task", e)
+        log_error('create_task', e)
         nil
       end
 
@@ -149,7 +149,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_task", e)
+        log_error('get_task', e)
         nil
       end
 
@@ -161,7 +161,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_task_status", e)
+        log_error('get_task_status', e)
         nil
       end
 
@@ -171,14 +171,14 @@ module BrainzLab
         params[:project_id] = project_id if project_id
         params[:status] = status if status
 
-        response = request(:get, "/api/v1/tasks", params: params)
+        response = request(:get, '/api/v1/tasks', params: params)
 
         return [] unless response.is_a?(Net::HTTPSuccess)
 
         data = JSON.parse(response.body, symbolize_names: true)
         data[:tasks] || []
       rescue StandardError => e
-        log_error("list_tasks", e)
+        log_error('list_tasks', e)
         []
       end
 
@@ -187,7 +187,7 @@ module BrainzLab
         response = request(:post, "/api/v1/tasks/#{task_id}/cancel")
         response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
       rescue StandardError => e
-        log_error("cancel_task", e)
+        log_error('cancel_task', e)
         false
       end
 
@@ -203,7 +203,7 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("get_logs", e)
+        log_error('get_logs', e)
         nil
       end
 
@@ -223,21 +223,21 @@ module BrainzLab
 
         JSON.parse(response.body, symbolize_names: true)
       rescue StandardError => e
-        log_error("exec", e)
+        log_error('exec', e)
         nil
       end
 
       def provision(project_id:, app_name:)
         response = request(
           :post,
-          "/api/v1/projects/provision",
+          '/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)
+        log_error('provision', e)
         false
       end
 
@@ -246,34 +246,32 @@ module BrainzLab
       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
+        uri.query = URI.encode_www_form(params) if params
 
         http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
+        http.use_ssl = uri.scheme == 'https'
         http.open_timeout = 10
-        http.read_timeout = 120  # Longer timeout for AI tasks
+        http.read_timeout = 120 # Longer timeout for AI tasks
 
         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
-
-        request["Content-Type"] = "application/json"
-        request["Accept"] = "application/json"
+                  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
+
+        request['Content-Type'] = 'application/json'
+        request['Accept'] = 'application/json'
 
         if use_service_key
-          request["X-Service-Key"] = @config.synapse_master_key || @config.secret_key
+          request['X-Service-Key'] = @config.synapse_master_key || @config.secret_key
         else
           auth_key = @config.synapse_api_key || @config.secret_key
-          request["Authorization"] = "Bearer #{auth_key}" if auth_key
+          request['Authorization'] = "Bearer #{auth_key}" if auth_key
         end
 
         headers.each { |k, v| request[k] = v }

data/lib/brainzlab/synapse/provisioner.rb

@@ -37,7 +37,7 @@ module BrainzLab
       end
 
       def detect_project_id
-        ENV["BRAINZLAB_PROJECT_ID"]
+        ENV.fetch('BRAINZLAB_PROJECT_ID', nil)
       end
     end
   end

data/lib/brainzlab/synapse.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "synapse/client"
-require_relative "synapse/provisioner"
+require_relative 'synapse/client'
+require_relative 'synapse/provisioner'
 
 module BrainzLab
   module Synapse
@@ -49,13 +49,13 @@ module BrainzLab
       #     ]
       #   )
       #
-      def create_project(name:, repos: [], description: nil, **options)
+      def create_project(name:, repos: [], description: nil, **)
         return nil unless enabled?
 
         ensure_provisioned!
         return nil unless BrainzLab.configuration.synapse_valid?
 
-        client.create_project(name: name, repos: repos, description: description, **options)
+        client.create_project(name: name, repos: repos, description: description, **)
       end
 
       # Start project containers
@@ -139,7 +139,7 @@ module BrainzLab
       #     priority: :high
       #   )
       #
-      def task(project_id:, description:, type: nil, priority: nil, **options)
+      def task(project_id:, description:, type: nil, priority: nil, **)
         return nil unless enabled?
 
         ensure_provisioned!
@@ -150,7 +150,7 @@ module BrainzLab
           description: description,
           type: type,
           priority: priority,
-          **options
+          **
         )
       end
 

data/lib/brainzlab/utilities/circuit_breaker.rb

@@ -31,7 +31,8 @@ module BrainzLab
 
       attr_reader :name, :state, :failure_count, :success_count, :last_failure_at
 
-      def initialize(name:, failure_threshold: 5, success_threshold: 2, recovery_timeout: 30, timeout: nil, exclude_exceptions: [])
+      def initialize(name:, failure_threshold: 5, success_threshold: 2, recovery_timeout: 30, timeout: nil,
+                     exclude_exceptions: [])
         @name = name
         @failure_threshold = failure_threshold
         @success_threshold = success_threshold
@@ -47,19 +48,18 @@ module BrainzLab
       end
 
       # Execute a block with circuit breaker protection
-      def call(fallback: nil)
+      def call(fallback: nil, &)
         check_state_transition!
 
         case @state
         when :open
           track_rejected
-          if fallback
-            fallback.respond_to?(:call) ? fallback.call : fallback
-          else
-            raise CircuitOpenError, "Circuit '#{@name}' is open"
-          end
+          raise CircuitOpenError, "Circuit '#{@name}' is open" unless fallback
+
+          fallback.respond_to?(:call) ? fallback.call : fallback
+
         when :closed, :half_open
-          execute_with_protection(fallback) { yield }
+          execute_with_protection(fallback, &)
         end
       end
 
@@ -112,13 +112,13 @@ module BrainzLab
           registry[name.to_s]
         end
 
-        def register(name, **options)
-          registry[name.to_s] = new(name: name, **options)
+        def register(name, **)
+          registry[name.to_s] = new(name: name, **)
         end
 
-        def call(name, **options, &block)
+        def call(name, **options, &)
           breaker = get(name) || register(name, **options)
-          breaker.call(**options.slice(:fallback), &block)
+          breaker.call(**options.slice(:fallback), &)
         end
 
         def reset_all!
@@ -132,35 +132,31 @@ module BrainzLab
 
       private
 
-      def execute_with_protection(fallback)
+      def execute_with_protection(fallback, &)
         result = if @timeout
-                   Timeout.timeout(@timeout) { yield }
+                   Timeout.timeout(@timeout, &)
                  else
                    yield
                  end
 
         record_success
         result
-      rescue *excluded_exceptions => e
+      rescue *excluded_exceptions
         # Don't count excluded exceptions as failures
         raise
       rescue StandardError => e
         record_failure(e)
 
-        if fallback
-          fallback.respond_to?(:call) ? fallback.call : fallback
-        else
-          raise
-        end
+        raise unless fallback
+
+        fallback.respond_to?(:call) ? fallback.call : fallback
       end
 
       def record_success
         @mutex.synchronize do
           if @state == :half_open
             @success_count += 1
-            if @success_count >= @success_threshold
-              transition_to(:closed)
-            end
+            transition_to(:closed) if @success_count >= @success_threshold
           else
             @failure_count = 0
           end
@@ -187,10 +183,10 @@ module BrainzLab
       def check_state_transition!
         return unless @state == :open && @last_failure_at
 
-        if Time.now - @last_failure_at >= @recovery_timeout
-          @mutex.synchronize do
-            transition_to(:half_open) if @state == :open
-          end
+        return unless Time.now - @last_failure_at >= @recovery_timeout
+
+        @mutex.synchronize do
+          transition_to(:half_open) if @state == :open
         end
       end
 
@@ -220,39 +216,39 @@ module BrainzLab
       def track_success
         return unless BrainzLab.configuration.flux_effectively_enabled?
 
-        BrainzLab::Flux.increment("circuit_breaker.success", tags: { name: @name, state: @state.to_s })
+        BrainzLab::Flux.increment('circuit_breaker.success', tags: { name: @name, state: @state.to_s })
       end
 
       def track_failure(error)
         return unless BrainzLab.configuration.flux_effectively_enabled?
 
-        BrainzLab::Flux.increment("circuit_breaker.failure", tags: {
-          name: @name,
-          state: @state.to_s,
-          error_class: error.class.name
-        })
+        BrainzLab::Flux.increment('circuit_breaker.failure', tags: {
+                                    name: @name,
+                                    state: @state.to_s,
+                                    error_class: error.class.name
+                                  })
       end
 
       def track_rejected
         return unless BrainzLab.configuration.flux_effectively_enabled?
 
-        BrainzLab::Flux.increment("circuit_breaker.rejected", tags: { name: @name })
+        BrainzLab::Flux.increment('circuit_breaker.rejected', tags: { name: @name })
       end
 
       def track_state_change(new_state, old_state = nil)
         return unless BrainzLab.configuration.flux_effectively_enabled?
 
-        BrainzLab::Flux.track("circuit_breaker.state_change", {
-          name: @name,
-          new_state: new_state.to_s,
-          old_state: old_state&.to_s,
-          failure_count: @failure_count
-        })
+        BrainzLab::Flux.track('circuit_breaker.state_change', {
+                                name: @name,
+                                new_state: new_state.to_s,
+                                old_state: old_state&.to_s,
+                                failure_count: @failure_count
+                              })
 
         # Also add breadcrumb for debugging
         BrainzLab::Reflex.add_breadcrumb(
           "Circuit '#{@name}' transitioned to #{new_state}",
-          category: "circuit_breaker",
+          category: 'circuit_breaker',
           level: new_state == :open ? :warning : :info,
           data: { name: @name, old_state: old_state, new_state: new_state }
         )