activerabbit-ai 0.4.8 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 954a33d564508a6af9e73defded58f6b4ea9f0b359da045d7566a91f7bfc846d
-  data.tar.gz: 4123b66a3933827a2bca1a78e2a235aa3a76abac2db5e209d60e6626edbdbc2f
+  metadata.gz: 7ca3568f93b7ec8211e47cf961fdf459f297a2d674fac08fe7c06a4001d09cdc
+  data.tar.gz: 6b3caffa37d7687c1d9038360c6787f7846e64bd30b722e4694b5d826b149a39
 SHA512:
-  metadata.gz: 4a4d4f10428dc2e7bf4b96606b1d0ddf809244f046bf5c4ec880a043d9a9436777851146b03e1882c8e306f512e9e83bef09148377e237348ee43246f35399a0
-  data.tar.gz: ca02b6426b33d2117455ae68d99fd20e47bb9ba792f8b18bd02b55caf09de6227a5442da53b4baa29221d81f3148dc19d34c67a578eced741f6f1c75629dc7af
+  metadata.gz: 7b6eda18a09800a68a7b159c39af0398e1017c5fb97a6dd83bc6956c0b6acbcbe1f424fcbbcc6ab70d79a830e8a15458ba62027f9b3b4fa23d095ffb9cdd0de6
+  data.tar.gz: 48e942cb18f611f795944be031ad0d4ac1637e103357f33cab5dd2ecc4229bd15476bd91291094a5d0fd8780b78744620b9a28c9f25245e3c71690c1dff6a1a4

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.5.0] - 2025-12-12
+
+### Changed
+- **Minor release**: Bumped version to 0.5.0 to reflect latest stable changes and internal improvements
+
+## [0.4.9] - 2025-11-30
+
+### Fixed
+- **Rails Integration**: Fixed `LocalJumpError: unexpected return` when `ActiveRabbit` is installed but not configured
+  - This error occurred when `subscribed` callbacks tried to return early if configuration was missing
+  - Changed `return` to `next` in Railtie subscription blocks
+
 ## [0.4.8] - 2025-11-27
 
 ### Added

data/TESTING_GUIDE.md

@@ -69,7 +69,7 @@ end
 RSpec.describe ActiveRabbit::Client::Configuration do
   describe "environment variable loading" do
     it "loads API key from environment" do
-      allow(ENV).to receive(:[]).with("active_rabbit_API_KEY").and_return("test-key")
+      allow(ENV).to receive(:[]).with("ACTIVERABBIT_API_KEY").and_return("test-key")
       config = described_class.new
       expect(config.api_key).to eq("test-key")
     end
@@ -486,8 +486,8 @@ puts "🧪 Testing ActiveRabbit Integration..."
 # Test 1: Configuration
 puts "\n1. Testing Configuration..."
 ActiveRabbit::Client.configure do |config|
-  config.api_key = ENV['active_rabbit_API_KEY'] || 'test-key'
-  config.project_id = ENV['active_rabbit_PROJECT_ID'] || 'test-project'
+  config.api_key = ENV['ACTIVERABBIT_API_KEY'] || 'test-key'
+  config.project_id = ENV['ACTIVERABBIT_PROJECT_ID'] || 'test-project'
   config.environment = 'test'
 end
 
@@ -578,8 +578,8 @@ jobs:
         bundle exec rspec
         ruby script/test_activerabbit.rb
       env:
-        active_rabbit_API_KEY: ${{ secrets.active_rabbit_API_KEY }}
-        active_rabbit_PROJECT_ID: ${{ secrets.active_rabbit_PROJECT_ID }}
+        ACTIVERABBIT_API_KEY: ${{ secrets.ACTIVERABBIT_API_KEY }}
+        ACTIVERABBIT_PROJECT_ID: ${{ secrets.ACTIVERABBIT_PROJECT_ID }}
 ```
 
 This comprehensive testing approach ensures your Rails application and ActiveRabbit gem integration is thoroughly tested before production deployment, covering functionality, performance, and resilience scenarios.

data/examples/rails_integration.rb

@@ -5,12 +5,12 @@
 # config/initializers/active_rabbit.rb
 ActiveRabbit::Client.configure do |config|
   # Required configuration
-  config.api_key = ENV['active_rabbit_API_KEY']
-  config.project_id = ENV['active_rabbit_PROJECT_ID']
+  config.api_key = ENV['ACTIVERABBIT_API_KEY']
+  config.project_id = ENV['ACTIVERABBIT_PROJECT_ID']
   config.environment = Rails.env
 
   # Optional configuration
-  config.api_url = ENV.fetch('active_rabbit_API_URL', 'https://api.activerabbit.com')
+  config.api_url = ENV.fetch('ACTIVERABBIT_API_URL', 'https://api.activerabbit.com')
   config.release = ENV['HEROKU_SLUG_COMMIT'] || `git rev-parse HEAD`.chomp
 
   # Performance settings

data/examples/standalone_usage.rb

@@ -140,8 +140,8 @@ class BackgroundWorker
   def initialize
     # Configure ActiveRabbit for background processes
     ActiveRabbit::Client.configure do |config|
-      config.api_key = ENV['active_rabbit_API_KEY']
-      config.project_id = ENV['active_rabbit_PROJECT_ID']
+      config.api_key = ENV['ACTIVERABBIT_API_KEY']
+      config.project_id = ENV['ACTIVERABBIT_PROJECT_ID']
       config.environment = ENV.fetch('ENVIRONMENT', 'development')
       config.server_name = "worker-#{Socket.gethostname}"
     end
@@ -249,8 +249,8 @@ namespace :data do
   desc "Migrate user data"
   task migrate_users: :environment do
     ActiveRabbit::Client.configure do |config|
-      config.api_key = ENV['active_rabbit_API_KEY']
-      config.project_id = ENV['active_rabbit_PROJECT_ID']
+      config.api_key = ENV['ACTIVERABBIT_API_KEY']
+      config.project_id = ENV['ACTIVERABBIT_PROJECT_ID']
       config.environment = 'migration'
     end
 

data/lib/active_rabbit/client/configuration.rb

@@ -16,12 +16,14 @@ module ActiveRabbit
       attr_accessor :before_send_event, :before_send_exception
       attr_accessor :dedupe_window  # Time window in seconds for error deduplication (0 = disabled)
       attr_accessor :revision
+      attr_accessor :auto_release_tracking
+      attr_accessor :disable_console_logs
 
       def initialize
-        @api_url = ENV.fetch("active_rabbit_API_URL", "https://api.activerabbit.ai")
-        @api_key = ENV["active_rabbit_API_KEY"]
-        @project_id = ENV["active_rabbit_PROJECT_ID"]
-        @environment = ENV.fetch("active_rabbit_ENVIRONMENT", detect_environment)
+        @api_url = ENV.fetch("ACTIVERABBIT_API_URL", "https://api.activerabbit.ai")
+        @api_key = ENV["ACTIVERABBIT_API_KEY"]
+        @project_id = ENV["ACTIVERABBIT_PROJECT_ID"]
+        @environment = ENV["ACTIVERABBIT_ENVIRONMENT"] || detect_environment
 
         # HTTP settings
         @timeout = 30
@@ -38,6 +40,7 @@ module ActiveRabbit
         @enable_performance_monitoring = true
         @enable_n_plus_one_detection = true
         @enable_pii_scrubbing = true
+        @disable_console_logs = true
 
         # PII scrubbing
         @pii_fields = %w[
@@ -66,9 +69,10 @@ module ActiveRabbit
         @dedupe_window = 300  # 5 minutes by default
 
         # Metadata
-        @release = detect_release
         @server_name = detect_server_name
         @logger = detect_logger
+        @auto_release_tracking = default_auto_release_tracking
+        @revision = detect_release
 
         # Callbacks
         @before_send_event = nil
@@ -136,6 +140,20 @@ module ActiveRabbit
         ENV["RACK_ENV"] || ENV["RAILS_ENV"] || "development"
       end
 
+      def default_auto_release_tracking
+        # Allow explicit override via env var
+        env_value = ENV["ACTIVERABBIT_AUTO_RELEASE_TRACKING"]
+        if env_value
+          normalized = env_value.to_s.strip.downcase
+          return true if %w[1 true yes y on].include?(normalized)
+          return false if %w[0 false no n off].include?(normalized)
+        end
+
+        # Default: enabled outside dev/test
+        env_name = @environment.to_s
+        !%w[development test].include?(env_name)
+      end
+
       def detect_release
         # Try to detect from common CI/deployment environment variables
         ENV["HEROKU_SLUG_COMMIT"] ||

data/lib/active_rabbit/client/exception_tracker.rb

@@ -32,25 +32,25 @@ module ActiveRabbit
         end
 
         # Send exception to API and return response
-        configuration.logger&.info("[ActiveRabbit] Preparing to send exception: #{exception.class.name}")
-        configuration.logger&.debug("[ActiveRabbit] Exception data: #{exception_data.inspect}")
+        log(:info, "[ActiveRabbit] Preparing to send exception: #{exception.class.name}")
+        log(:debug, "[ActiveRabbit] Exception data: #{exception_data.inspect}")
 
         # Ensure we have required fields
         unless exception_data[:exception_class] && exception_data[:message] && exception_data[:backtrace]
-          configuration.logger&.error("[ActiveRabbit] Missing required fields in exception data")
-          configuration.logger&.debug("[ActiveRabbit] Available fields: #{exception_data.keys.inspect}")
+          log(:error, "[ActiveRabbit] Missing required fields in exception data")
+          log(:debug, "[ActiveRabbit] Available fields: #{exception_data.keys.inspect}")
           return nil
         end
 
         response = http_client.post_exception(exception_data)
 
         if response.nil?
-          configuration.logger&.error("[ActiveRabbit] Failed to send exception - both primary and fallback endpoints failed")
+          log(:error, "[ActiveRabbit] Failed to send exception - both primary and fallback endpoints failed")
           return nil
         end
 
-        configuration.logger&.info("[ActiveRabbit] Exception successfully sent to API")
-        configuration.logger&.debug("[ActiveRabbit] API Response: #{response.inspect}")
+        log(:info, "[ActiveRabbit] Exception successfully sent to API")
+        log(:debug, "[ActiveRabbit] API Response: #{response.inspect}")
         response
       end
 
@@ -60,6 +60,22 @@ module ActiveRabbit
 
       private
 
+      def log(level, message)
+        cfg = configuration
+        return if cfg&.disable_console_logs
+
+        logger = cfg&.logger
+        return unless logger
+
+        case level
+        when :info  then logger.info(message)
+        when :debug then logger.debug(message)
+        when :error then logger.error(message)
+        end
+
+      rescue
+      end
+
       def build_exception_data(exception:, context:, user_id:, tags:, handled: nil)
         parsed_bt = parse_backtrace(exception.backtrace || [])
         backtrace_lines = parsed_bt.map { |frame| frame[:line] }
@@ -132,10 +148,10 @@ module ActiveRabbit
         end
 
         # Log what we're sending
-        configuration.logger&.debug("[ActiveRabbit] Built exception data:")
-        configuration.logger&.debug("[ActiveRabbit] - Required fields: class=#{data[:exception_class]}, message=#{data[:message]}, backtrace=#{data[:backtrace]&.first}")
-        configuration.logger&.debug("[ActiveRabbit] - Error details: type=#{data[:error_type]}, source=#{data[:error_source]}, component=#{data[:error_component]}")
-        configuration.logger&.debug("[ActiveRabbit] - Request info: path=#{data[:request_path]}, method=#{data[:request_method]}, action=#{data[:controller_action]}")
+        log(:debug, "[ActiveRabbit] Built exception data:")
+        log(:debug, "[ActiveRabbit] - Required fields: class=#{data[:exception_class]}, message=#{data[:message]}, backtrace=#{data[:backtrace]&.first}")
+        log(:debug, "[ActiveRabbit] - Error details: type=#{data[:error_type]}, source=#{data[:error_source]}, component=#{data[:error_component]}")
+        log(:debug, "[ActiveRabbit] - Request info: path=#{data[:request_path]}, method=#{data[:request_method]}, action=#{data[:controller_action]}")
 
         data
       end

data/lib/active_rabbit/client/http_client.rb

@@ -37,33 +37,33 @@ module ActiveRabbit
         # Primary endpoint path
         path = "/api/v1/events/errors"
 
-        configuration.logger&.info("[ActiveRabbit] Sending exception to API...")
-        configuration.logger&.debug("[ActiveRabbit] Exception payload (pre-JSON): #{safe_preview(exception_data_with_type)}")
-        configuration.logger&.debug("[ActiveRabbit] Target path: #{path}")
+        log(:info, "[ActiveRabbit] Sending exception to API...")
+        log(:debug, "[ActiveRabbit] Exception payload (pre-JSON): #{safe_preview(exception_data_with_type)}")
+        log(:debug, "[ActiveRabbit] Target path: #{path}")
 
         begin
           # Primary endpoint attempt
-          configuration.logger&.info("[ActiveRabbit] Making request to primary endpoint: POST #{path}")
+          log(:info, "[ActiveRabbit] Making request to primary endpoint: POST #{path}")
           response = enqueue_request(:post, path, exception_data_with_type)
-          configuration.logger&.info("[ActiveRabbit] Exception sent successfully (errors endpoint)")
+          log(:info, "[ActiveRabbit] Exception sent successfully (errors endpoint)")
           return response
         rescue => e
-          configuration.logger&.error("[ActiveRabbit] Primary send failed: #{e.class}: #{e.message}")
-          configuration.logger&.error("[ActiveRabbit] Primary error backtrace: #{e.backtrace&.first(3)}")
-          configuration.logger&.debug("[ActiveRabbit] Falling back to /api/v1/events with type=error")
+          log(:error, "[ActiveRabbit] Primary send failed: #{e.class}: #{e.message}")
+          log(:error, "[ActiveRabbit] Primary error backtrace: #{e.backtrace&.first(3)}")
+          log(:debug, "[ActiveRabbit] Falling back to /api/v1/events with type=error")
 
           begin
             # Fallback to generic events endpoint
             fallback_path = "/api/v1/events"
             fallback_body = { type: "error", data: exception_data_with_type }
-            configuration.logger&.info("[ActiveRabbit] Making request to fallback endpoint: POST #{fallback_path}")
+            log(:info, "[ActiveRabbit] Making request to fallback endpoint: POST #{fallback_path}")
             response = enqueue_request(:post, fallback_path, fallback_body)
-            configuration.logger&.info("[ActiveRabbit] Exception sent via fallback endpoint")
+            log(:info, "[ActiveRabbit] Exception sent via fallback endpoint")
             return response
           rescue => e2
-            configuration.logger&.error("[ActiveRabbit] Fallback send failed: #{e2.class}: #{e2.message}")
-            configuration.logger&.error("[ActiveRabbit] Fallback error backtrace: #{e2.backtrace&.first(3)}")
-            configuration.logger&.error("[ActiveRabbit] All exception sending attempts failed")
+            log(:error, "[ActiveRabbit] Fallback send failed: #{e2.class}: #{e2.message}")
+            log(:error, "[ActiveRabbit] Fallback error backtrace: #{e2.backtrace&.first(3)}")
+            log(:error, "[ActiveRabbit] All exception sending attempts failed")
             nil
           end
         end
@@ -85,31 +85,36 @@ module ActiveRabbit
         end
 
         # Send batch to API
-        configuration.logger&.info("[ActiveRabbit] Sending batch of #{events.length} events...")
+        log(:info, "[ActiveRabbit] Sending batch of #{events.length} events...")
         response = make_request(:post, "/api/v1/events/batch", { events: events })
-        configuration.logger&.info("[ActiveRabbit] Batch sent successfully")
-        configuration.logger&.debug("[ActiveRabbit] Batch response: #{response.inspect}")
+        log(:info, "[ActiveRabbit] Batch sent successfully")
+        log(:debug, "[ActiveRabbit] Batch response: #{response.inspect}")
         response
       end
 
-      def post(path, payload)
-        uri = URI.join(@base_uri.to_s, path)
-        req = Net::HTTP::Post.new(uri)
-        req['Content-Type'] = 'application/json'
-        req["X-Project-Token"] = configuration.api_key
-        req.body = payload.to_json
+      # Create (or confirm) a release in the ActiveRabbit API.
+      # Treats 409 conflict (already exists) as success to support multiple servers/dynos.
+      def post_release(release_data)
+        payload = stringify_and_sanitize(release_data)
+        uri = build_uri("/api/v1/releases")
 
-        res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
-          http.request(req)
-        end
+        log(:info, "[ActiveRabbit] Pinging release to API...")
+        log(:debug, "[ActiveRabbit] Release payload: #{safe_preview(payload)}")
 
-        unless res.is_a?(Net::HTTPSuccess)
-          raise APIError, "ActiveRabbit API request failed: #{res.code} #{res.body}"
-        end
+        response = perform_request(uri, :post, payload)
+        code = response.code.to_i
 
-        JSON.parse(res.body)
+        if (200..299).include?(code)
+          parse_json_or_empty(response.body)
+        elsif code == 409
+          # Already exists; return parsed body (usually includes id/version)
+          parse_json_or_empty(response.body)
+        else
+          # Use shared error handling (raises)
+          handle_response(response)
+        end
       rescue => e
-        @configuration.logger&.error("[ActiveRabbit] HTTP POST failed: #{e.class}: #{e.message}")
+        log(:error, "[ActiveRabbit] Release ping failed: #{e.class}: #{e.message}")
         nil
       end
 
@@ -126,18 +131,18 @@ module ActiveRabbit
       def flush
         return if @request_queue.empty?
 
-        configuration.logger&.info("[ActiveRabbit] Starting flush with #{@request_queue.length} items")
+        log(:info, "[ActiveRabbit] Starting flush with #{@request_queue.length} items")
         batch = @request_queue.shift(@request_queue.length)
         return if batch.empty?
 
         begin
-          configuration.logger&.info("[ActiveRabbit] Sending batch of #{batch.length} items")
+          log(:info, "[ActiveRabbit] Sending batch of #{batch.length} items")
           response = post_batch(batch)
-          configuration.logger&.info("[ActiveRabbit] Batch sent successfully: #{response.inspect}")
+          log(:info, "[ActiveRabbit] Batch sent successfully: #{response.inspect}")
           response
         rescue => e
-          configuration.logger&.error("[ActiveRabbit] Failed to send batch: #{e.message}")
-          configuration.logger&.error("[ActiveRabbit] Backtrace: #{e.backtrace&.first(3)}")
+          log(:error, "[ActiveRabbit] Failed to send batch: #{e.message}")
+          log(:error, "[ActiveRabbit] Backtrace: #{e.backtrace&.first(3)}")
           raise APIError, "Failed to send batch: #{e.message}"
         end
       end
@@ -150,6 +155,20 @@ module ActiveRabbit
 
       private
 
+      def build_uri(path)
+        current_base = URI(configuration.api_url)
+        normalized_path = path.start_with?("/") ? path : "/#{path}"
+        URI.join(current_base, normalized_path)
+      end
+
+      def parse_json_or_empty(body)
+        return {} if body.nil? || body.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        body
+      end
+
       def enqueue_request(method, path, data)
         return if @shutdown
 
@@ -161,8 +180,8 @@ module ActiveRabbit
           timestamp: Time.now.to_f
         }
 
-        configuration.logger&.info("[ActiveRabbit] Enqueueing request: #{method} #{path}")
-        configuration.logger&.debug("[ActiveRabbit] Request data: #{data.inspect}")
+        log(:info, "[ActiveRabbit] Enqueueing request: #{method} #{path}")
+        log(:debug, "[ActiveRabbit] Request data: #{data.inspect}")
 
         @request_queue << formatted_data
 
@@ -190,9 +209,9 @@ module ActiveRabbit
         # Ensure path starts with a single leading slash
         normalized_path = path.start_with?("/") ? path : "/#{path}"
         uri = URI.join(current_base, normalized_path)
-        configuration.logger&.info("[ActiveRabbit] Making request: #{method.upcase} #{uri}")
-        configuration.logger&.debug("[ActiveRabbit] Request headers: X-Project-Token=#{configuration.api_key}, X-Project-ID=#{configuration.project_id}")
-        configuration.logger&.debug("[ActiveRabbit] Request body: #{safe_preview(data)}")
+        log(:info, "[ActiveRabbit] Making request: #{method.upcase} #{uri}")
+        log(:debug, "[ActiveRabbit] Request headers: X-Project-Token=#{configuration.api_key}, X-Project-ID=#{configuration.project_id}")
+        log(:debug, "[ActiveRabbit] Request body: #{safe_preview(data)}")
 
         # Retry logic with exponential backoff
         retries = 0
@@ -200,17 +219,17 @@ module ActiveRabbit
 
         begin
           response = perform_request(uri, method, data)
-          configuration.logger&.info("[ActiveRabbit] Response status: #{response.code}")
-          configuration.logger&.debug("[ActiveRabbit] Response headers: #{response.to_hash.inspect}")
-          configuration.logger&.debug("[ActiveRabbit] Response body: #{response.body}")
+          log(:info, "[ActiveRabbit] Response status: #{response.code}")
+          log(:debug, "[ActiveRabbit] Response headers: #{response.to_hash.inspect}")
+          log(:debug, "[ActiveRabbit] Response body: #{response.body}")
 
           result = handle_response(response)
-          configuration.logger&.debug("[ActiveRabbit] Parsed response: #{result.inspect}")
+          log(:debug, "[ActiveRabbit] Parsed response: #{result.inspect}")
           result
         rescue RetryableError => e
           if retries < max_retries
             retries += 1
-            configuration.logger&.info("[ActiveRabbit] Retrying request (#{retries}/#{max_retries})")
+            log(:info, "[ActiveRabbit] Retrying request (#{retries}/#{max_retries})")
             sleep(configuration.retry_delay * (2 ** (retries - 1)))
             retry
           end
@@ -218,7 +237,7 @@ module ActiveRabbit
         rescue Net::OpenTimeout, Net::ReadTimeout => e
           if retries < max_retries && should_retry_error?(e)
             retries += 1
-            configuration.logger&.info("[ActiveRabbit] Retrying request after timeout (#{retries}/#{max_retries})")
+            log(:info, "[ActiveRabbit] Retrying request after timeout (#{retries}/#{max_retries})")
             sleep(configuration.retry_delay * (2 ** (retries - 1))) # Exponential backoff
             retry
           end
@@ -226,24 +245,24 @@ module ActiveRabbit
         rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, SocketError => e
           if retries < max_retries
             retries += 1
-            configuration.logger&.info("[ActiveRabbit] Retrying request after connection error (#{retries}/#{max_retries})")
+            log(:info, "[ActiveRabbit] Retrying request after connection error (#{retries}/#{max_retries})")
             sleep(configuration.retry_delay * (2 ** (retries - 1)))
             retry
           end
           raise APIError, "Connection failed after #{retries} retries: #{e.message}"
         rescue APIError, RateLimitError => e
           # Re-raise API errors as-is
-          configuration.logger&.error("[ActiveRabbit] API error: #{e.class}: #{e.message}")
+          log(:error, "[ActiveRabbit] API error: #{e.class}: #{e.message}")
           raise e
         rescue => e
-          configuration.logger&.error("[ActiveRabbit] Request failed: #{e.class}: #{e.message}")
-          configuration.logger&.error("[ActiveRabbit] Backtrace: #{e.backtrace&.first(3)}")
+          log(:error, "[ActiveRabbit] Request failed: #{e.class}: #{e.message}")
+          log(:error, "[ActiveRabbit] Backtrace: #{e.backtrace&.first(3)}")
           raise APIError, "Request failed: #{e.message}"
         end
       end
 
       def perform_request(uri, method, data)
-        configuration.logger&.debug("[ActiveRabbit] Making HTTP request: #{method.upcase} #{uri}")
+        log(:debug, "[ActiveRabbit] Making HTTP request: #{method.upcase} #{uri}")
         http = Net::HTTP.new(uri.host, uri.port)
 
         # Configure SSL if HTTPS
@@ -270,7 +289,7 @@ module ActiveRabbit
                     raise ArgumentError, "Unsupported HTTP method: #{method}"
                   end
 
-        configuration.logger&.debug("[ActiveRabbit] Request path: #{uri.request_uri}")
+        log(:debug, "[ActiveRabbit] Request path: #{uri.request_uri}")
 
         # Set headers
         request['Content-Type'] = 'application/json'
@@ -291,8 +310,8 @@ module ActiveRabbit
       end
 
       def handle_response(response)
-        configuration.logger&.debug("[ActiveRabbit] Response code: #{response.code}")
-        configuration.logger&.debug("[ActiveRabbit] Response body: #{response.body}")
+        log(:debug, "[ActiveRabbit] Response code: #{response.code}")
+        log(:debug, "[ActiveRabbit] Response body: #{response.body}")
 
         case response.code.to_i
         when 200..299
@@ -300,23 +319,23 @@ module ActiveRabbit
           if response.body && !response.body.empty?
             begin
               parsed = JSON.parse(response.body)
-              configuration.logger&.debug("[ActiveRabbit] Parsed response: #{parsed.inspect}")
+              log(:debug, "[ActiveRabbit] Parsed response: #{parsed.inspect}")
               parsed
             rescue JSON::ParserError => e
-              configuration.logger&.error("[ActiveRabbit] Failed to parse response: #{e.message}")
-              configuration.logger&.error("[ActiveRabbit] Raw response: #{response.body}")
+              log(:error, "[ActiveRabbit] Failed to parse response: #{e.message}")
+              log(:error, "[ActiveRabbit] Raw response: #{response.body}")
               response.body
             end
           else
-            configuration.logger&.debug("[ActiveRabbit] Empty response body")
+            log(:debug, "[ActiveRabbit] Empty response body")
             {}
           end
         when 429
-          configuration.logger&.error("[ActiveRabbit] Rate limit exceeded")
+          log(:error, "[ActiveRabbit] Rate limit exceeded")
           raise RateLimitError, "Rate limit exceeded"
         when 400..499
           error_message = extract_error_message(response)
-          configuration.logger&.error("[ActiveRabbit] Client error (#{response.code}): #{error_message}")
+          log(:error, "[ActiveRabbit] Client error (#{response.code}): #{error_message}")
           raise APIError, "Client error (#{response.code}): #{error_message}"
         when 500..599
           error_message = extract_error_message(response)
@@ -324,11 +343,11 @@ module ActiveRabbit
             configuration.logger&.warn("[ActiveRabbit] Retryable server error (#{response.code}): #{error_message}")
             raise RetryableError, "Server error (#{response.code}): #{error_message}"
           else
-            configuration.logger&.error("[ActiveRabbit] Server error (#{response.code}): #{error_message}")
+            log(:error, "[ActiveRabbit] Server error (#{response.code}): #{error_message}")
             raise APIError, "Server error (#{response.code}): #{error_message}"
           end
         else
-          configuration.logger&.error("[ActiveRabbit] Unexpected response code: #{response.code}")
+          log(:error, "[ActiveRabbit] Unexpected response code: #{response.code}")
           raise APIError, "Unexpected response code: #{response.code}"
         end
       end
@@ -383,7 +402,22 @@ module ActiveRabbit
         s = obj.inspect
         s.length > 2000 ? s[0,2000] + "...(truncated)" : s
       end
-    end
 
+      def log(level, message)
+        return if configuration.disable_console_logs
+
+        logger = configuration.logger
+        return unless logger
+
+        case level
+        when :info
+          logger.info(message)
+        when :debug
+          logger.debug(message)
+        when :error
+          logger.error(message)
+        end
+      end
+    end
   end
 end

data/lib/active_rabbit/client/railtie.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "logger"
+require "concurrent"
 
 begin
   require "rails/railtie"
@@ -21,40 +22,76 @@ module ActiveRabbit
       config.active_rabbit = ActiveSupport::OrderedOptions.new
 
       initializer "active_rabbit.configure", after: :initialize_logger do |app|
-        if Rails.env.development?
-          puts "\n=== ActiveRabbit Configure ==="
-          puts "Environment: #{Rails.env}"
-          puts "Already configured? #{ActiveRabbit::Client.configured?}"
-          puts "================================\n"
+        apply_rails_configuration(app.config.active_rabbit)
+
+        if ActiveRabbit::Client.configuration && !ActiveRabbit::Client.configuration.disable_console_logs
+          if Rails.env.development?
+            ar_puts "\n=== ActiveRabbit Configure ==="
+            ar_puts "Environment: #{Rails.env}"
+            ar_puts "Already configured? #{ActiveRabbit::Client.configured?}"
+            ar_puts "================================\n"
+          end
         end
 
         # Configure ActiveRabbit from Rails configuration
         ActiveRabbit::Client.configure do |config|
-          config.environment = Rails.env
-          config.logger = Rails.logger rescue Logger.new(STDOUT)
-          config.release = detect_release(app)
+          config.environment ||= Rails.env
+          config.logger ||= Rails.logger rescue Logger.new(STDOUT)
+          config.release ||= detect_release(app)
         end
 
-        if Rails.env.development?
-          puts "\n=== ActiveRabbit Post-Configure ==="
-          puts "Now configured? #{ActiveRabbit::Client.configured?}"
-          puts "Configuration: #{ActiveRabbit::Client.configuration.inspect}"
-          puts "================================\n"
+        app.config.after_initialize do
+          begin
+            cfg = ActiveRabbit::Client.configuration
+            next unless cfg
+            next unless ActiveRabbit::Client.configured?
+            next unless cfg.auto_release_tracking
+
+            version = cfg.revision || cfg.release
+            next if version.nil? || version.to_s.strip.empty?
+
+            metadata = {
+              revision: cfg.revision,
+              release: cfg.release,
+              server_name: cfg.server_name,
+              environment: cfg.environment,
+              gem_version: ActiveRabbit::Client::VERSION
+            }.compact
+
+            Concurrent::Future.execute do
+              ActiveRabbit::Client.notify_release(
+                version: version,
+                environment: cfg.environment,
+                metadata: metadata
+              )
+            end
+          rescue => e
+            Rails.logger.debug "[ActiveRabbit] auto release tracking failed: #{e.class}: #{e.message}" if defined?(Rails) && Rails.logger
+          end
         end
 
+        # if ActiveRabbit::Client.configuration && !ActiveRabbit::Client.configuration.disable_console_logs
+        #   if Rails.env.development?
+        #     ar_puts "\n=== ActiveRabbit Post-Configure ==="
+        #     ar_puts "Now configured? #{ActiveRabbit::Client.configured?}"
+        #     ar_puts "Configuration: #{ActiveRabbit::Client.configuration.inspect}"
+        #     ar_puts "================================\n"
+        #   end
+        # end
+
         # Set up exception tracking
         setup_exception_tracking(app) if ActiveRabbit::Client.configured?
       end
 
       initializer "active_rabbit.subscribe_to_notifications", after: :load_config_initializers do |app|
-        Rails.logger.info "[ActiveRabbit] Setting up performance notifications subscriptions"
+        ar_log(:info, "[ActiveRabbit] Setting up performance notifications subscriptions")
         # Subscribe regardless; each handler guards on configured?
         subscribe_to_controller_events
         subscribe_to_active_record_events
         subscribe_to_action_view_events
         subscribe_to_action_mailer_events if defined?(ActionMailer)
         subscribe_to_exception_notifications
-        Rails.logger.info "[ActiveRabbit] Subscriptions setup complete"
+        ar_log(:info, "[ActiveRabbit] Subscriptions setup complete")
 
         # Defer complex subscriptions until after initialization
         app.config.after_initialize do
@@ -85,83 +122,83 @@ module ActiveRabbit
       # Configure middleware after logger is initialized to avoid init cycles
       initializer "active_rabbit.add_middleware", after: :initialize_logger do |app|
         if Rails.env.development?
-          puts "\n=== ActiveRabbit Railtie Loading ==="
-          puts "Rails Environment: #{Rails.env}"
-          puts "Rails Middleware Stack Phase: #{app.middleware.respond_to?(:middlewares) ? 'Ready' : 'Not Ready'}"
-          puts "================================\n"
-          puts "\n=== Initial Middleware Stack ==="
-          puts "(not available at this boot phase)"
-          puts "=======================\n"
+          ar_puts "\n=== ActiveRabbit Railtie Loading ==="
+          ar_puts "Rails Environment: #{Rails.env}"
+          ar_puts "Rails Middleware Stack Phase: #{app.middleware.respond_to?(:middlewares) ? 'Ready' : 'Not Ready'}"
+          ar_puts "================================\n"
+          ar_puts "\n=== Initial Middleware Stack ==="
+          ar_puts "(not available at this boot phase)"
+          ar_puts "=======================\n"
         end
 
-        puts "\n=== Adding ActiveRabbit Middleware ===" if Rails.env.development?
+        ar_puts "\n=== Adding ActiveRabbit Middleware ===" if Rails.env.development?
         # Handle both development (DebugExceptions) and production (ShowExceptions)
         if defined?(ActionDispatch::DebugExceptions)
-          puts "[ActiveRabbit] Found DebugExceptions, configuring middleware..." if Rails.env.development?
+          ar_puts "[ActiveRabbit] Found DebugExceptions, configuring middleware..." if Rails.env.development?
 
           # First remove any existing middleware to avoid duplicates
           begin
             app.config.middleware.delete(ActiveRabbit::Client::ExceptionMiddleware)
             app.config.middleware.delete(ActiveRabbit::Client::RequestContextMiddleware)
             app.config.middleware.delete(ActiveRabbit::Client::RoutingErrorCatcher)
-            puts "[ActiveRabbit] Cleaned up existing middleware" if Rails.env.development?
+            ar_puts "[ActiveRabbit] Cleaned up existing middleware" if Rails.env.development?
           rescue => e
-            puts "[ActiveRabbit] Error cleaning middleware: #{e.message}"
+            ar_puts "[ActiveRabbit] Error cleaning middleware: #{e.message}"
           end
 
           # Insert middleware in the correct order
-          puts "[ActiveRabbit] Inserting middleware..." if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting middleware..." if Rails.env.development?
 
           # Insert ErrorCaptureMiddleware after DebugExceptions to rely on rescue path
           app.config.middleware.insert_after(ActionDispatch::DebugExceptions, ActiveRabbit::Middleware::ErrorCaptureMiddleware)
 
           # Insert RequestContextMiddleware early in the stack
-          puts "[ActiveRabbit] Inserting RequestContextMiddleware before RequestId" if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting RequestContextMiddleware before RequestId" if Rails.env.development?
           app.config.middleware.insert_before(ActionDispatch::RequestId, ActiveRabbit::Client::RequestContextMiddleware)
 
           # Insert ExceptionMiddleware before Rails' exception handlers (kept for env-based reporting)
-          puts "[ActiveRabbit] Inserting ExceptionMiddleware before DebugExceptions" if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting ExceptionMiddleware before DebugExceptions" if Rails.env.development?
           app.config.middleware.insert_before(ActionDispatch::DebugExceptions, ActiveRabbit::Client::ExceptionMiddleware)
 
           # Insert RoutingErrorCatcher after Rails' exception handlers
-          puts "[ActiveRabbit] Inserting RoutingErrorCatcher after DebugExceptions" if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting RoutingErrorCatcher after DebugExceptions" if Rails.env.development?
           app.config.middleware.insert_after(ActionDispatch::DebugExceptions, ActiveRabbit::Client::RoutingErrorCatcher)
 
-          puts "[ActiveRabbit] Middleware insertion complete" if Rails.env.development?
+          ar_puts "[ActiveRabbit] Middleware insertion complete" if Rails.env.development?
 
         elsif defined?(ActionDispatch::ShowExceptions)
-          puts "[ActiveRabbit] Found ShowExceptions, configuring middleware..." if Rails.env.development?
+          ar_puts "[ActiveRabbit] Found ShowExceptions, configuring middleware..." if Rails.env.development?
 
           # First remove any existing middleware to avoid duplicates
           begin
             app.config.middleware.delete(ActiveRabbit::Client::ExceptionMiddleware)
             app.config.middleware.delete(ActiveRabbit::Client::RequestContextMiddleware)
             app.config.middleware.delete(ActiveRabbit::Client::RoutingErrorCatcher)
-            puts "[ActiveRabbit] Cleaned up existing middleware" if Rails.env.development?
+            ar_puts "[ActiveRabbit] Cleaned up existing middleware" if Rails.env.development?
           rescue => e
-            puts "[ActiveRabbit] Error cleaning middleware: #{e.message}"
+            ar_puts "[ActiveRabbit] Error cleaning middleware: #{e.message}"
           end
 
           # Insert middleware in the correct order
-          puts "[ActiveRabbit] Inserting middleware..." if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting middleware..." if Rails.env.development?
 
           # Insert ErrorCaptureMiddleware after ShowExceptions
           app.config.middleware.insert_after(ActionDispatch::ShowExceptions, ActiveRabbit::Middleware::ErrorCaptureMiddleware)
 
           # Insert RequestContextMiddleware early in the stack
-          puts "[ActiveRabbit] Inserting RequestContextMiddleware before RequestId" if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting RequestContextMiddleware before RequestId" if Rails.env.development?
           app.config.middleware.insert_before(ActionDispatch::RequestId, ActiveRabbit::Client::RequestContextMiddleware)
 
           # Insert ExceptionMiddleware before Rails' exception handlers
-          puts "[ActiveRabbit] Inserting ExceptionMiddleware before ShowExceptions" if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting ExceptionMiddleware before ShowExceptions" if Rails.env.development?
           app.config.middleware.insert_before(ActionDispatch::ShowExceptions, ActiveRabbit::Client::ExceptionMiddleware)
 
           # Insert RoutingErrorCatcher after Rails' exception handlers
-          puts "[ActiveRabbit] Inserting RoutingErrorCatcher after ShowExceptions" if Rails.env.development?
+          ar_puts "[ActiveRabbit] Inserting RoutingErrorCatcher after ShowExceptions" if Rails.env.development?
           app.config.middleware.insert_after(ActionDispatch::ShowExceptions, ActiveRabbit::Client::RoutingErrorCatcher)
 
         else
-          puts "[ActiveRabbit] No exception handlers found, using fallback configuration" if Rails.env.development?
+          ar_puts "[ActiveRabbit] No exception handlers found, using fallback configuration" if Rails.env.development?
           app.config.middleware.use(ActiveRabbit::Middleware::ErrorCaptureMiddleware)
           app.config.middleware.use(ActiveRabbit::Client::RequestContextMiddleware)
           app.config.middleware.use(ActiveRabbit::Client::ExceptionMiddleware)
@@ -169,9 +206,9 @@ module ActiveRabbit
         end
 
         if Rails.env.development?
-          puts "\n=== Final Middleware Stack ==="
-          puts "(will be printed after initialize)"
-          puts "=======================\n"
+          ar_puts "\n=== Final Middleware Stack ==="
+          ar_puts "(will be printed after initialize)"
+          ar_puts "=======================\n"
         end
 
           # Add debug wrappers in development
@@ -180,41 +217,42 @@ module ActiveRabbit
           ActiveRabbit::Client::ExceptionMiddleware.class_eval do
             alias_method :__ar_original_call, :call unless method_defined?(:__ar_original_call)
             def call(env)
-              puts "\n=== ExceptionMiddleware Enter ==="
-              puts "Path: #{env['PATH_INFO']}"
-              puts "Method: #{env['REQUEST_METHOD']}"
-              puts "Current Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
-              puts "Current Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
-              puts "Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
-              puts "Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                    ")}"
-              puts "Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                ")}"
-              puts "Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n               ")}"
-              puts "============================\n"
+              cfg = ActiveRabbit::Client.configuration
+              ar_puts "\n=== ExceptionMiddleware Enter ==="
+              ar_puts "Path: #{env['PATH_INFO']}"
+              ar_puts "Method: #{env['REQUEST_METHOD']}"
+              ar_puts "Current Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
+              ar_puts "Current Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
+              ar_puts "Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
+              ar_puts "Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                    ")}"
+              ar_puts "Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                ")}"
+              ar_puts "Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n               ")}"
+              ar_puts "============================\n"
 
               begin
                 status, headers, body = __ar_original_call(env)
-                puts "\n=== ExceptionMiddleware Exit (Success) ==="
-                puts "Status: #{status}"
-                puts "Headers: #{headers.inspect}"
-                puts "Final Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
-                puts "Final Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
-                puts "Final Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
-                puts "Final Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                          ")}"
-                puts "Final Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                      ")}"
-                puts "Final Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n                     ")}"
-                puts "===========================\n"
+                ar_puts "\n=== ExceptionMiddleware Exit (Success) ==="
+                ar_puts "Status: #{status}"
+                ar_puts "Headers: #{headers.inspect}"
+                ar_puts "Final Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
+                ar_puts "Final Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
+                ar_puts "Final Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
+                ar_puts "Final Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                          ")}"
+                ar_puts "Final Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                      ")}"
+                ar_puts "Final Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n                     ")}"
+                ar_puts "===========================\n"
                 [status, headers, body]
               rescue => e
-                puts "\n=== ExceptionMiddleware Exit (Error) ==="
-                puts "Error: #{e.class} - #{e.message}"
-                puts "Error Backtrace: #{e.backtrace&.first(3)&.join("\n              ")}"
-                puts "Original Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
-                puts "Original Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
-                puts "Original Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
-                puts "Original Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                          ")}"
-                puts "Original Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                      ")}"
-                puts "Original Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n                     ")}"
-                puts "===========================\n"
+                ar_puts "\n=== ExceptionMiddleware Exit (Error) ==="
+                ar_puts "Error: #{e.class} - #{e.message}"
+                ar_puts "Error Backtrace: #{e.backtrace&.first(3)&.join("\n              ")}"
+                ar_puts "Original Exception: #{env['action_dispatch.exception']&.class} - #{env['action_dispatch.exception']&.message}"
+                ar_puts "Original Error: #{env['action_dispatch.error']&.class} - #{env['action_dispatch.error']&.message}"
+                ar_puts "Original Rack Exception: #{env['rack.exception']&.class} - #{env['rack.exception']&.message}"
+                ar_puts "Original Exception Backtrace: #{env['action_dispatch.exception']&.backtrace&.first(3)&.join("\n                          ")}"
+                ar_puts "Original Error Backtrace: #{env['action_dispatch.error']&.backtrace&.first(3)&.join("\n                      ")}"
+                ar_puts "Original Rack Backtrace: #{env['rack.exception']&.backtrace&.first(3)&.join("\n                     ")}"
+                ar_puts "===========================\n"
                 raise
               end
             end
@@ -224,23 +262,23 @@ module ActiveRabbit
           ActiveRabbit::Client::RoutingErrorCatcher.class_eval do
             alias_method :__ar_routing_original_call, :call unless method_defined?(:__ar_routing_original_call)
             def call(env)
-              puts "\n=== RoutingErrorCatcher Enter ==="
-              puts "Path: #{env['PATH_INFO']}"
-              puts "Method: #{env['REQUEST_METHOD']}"
-              puts "Status: #{env['action_dispatch.exception']&.class}"
-              puts "============================\n"
+              ar_puts "\n=== RoutingErrorCatcher Enter ==="
+              ar_puts "Path: #{env['PATH_INFO']}"
+              ar_puts "Method: #{env['REQUEST_METHOD']}"
+              ar_puts "Status: #{env['action_dispatch.exception']&.class}"
+              ar_puts "============================\n"
 
               begin
                 status, headers, body = __ar_routing_original_call(env)
-                puts "\n=== RoutingErrorCatcher Exit (Success) ==="
-                puts "Status: #{status}"
-                puts "===========================\n"
+                ar_puts "\n=== RoutingErrorCatcher Exit (Success) ==="
+                ar_puts "Status: #{status}"
+                ar_puts "===========================\n"
                 [status, headers, body]
               rescue => e
-                puts "\n=== RoutingErrorCatcher Exit (Error) ==="
-                puts "Error: #{e.class} - #{e.message}"
-                puts "Backtrace: #{e.backtrace&.first(3)&.join("\n           ")}"
-                puts "===========================\n"
+                ar_puts "\n=== RoutingErrorCatcher Exit (Error) ==="
+                ar_puts "Error: #{e.class} - #{e.message}"
+                ar_puts "Backtrace: #{e.backtrace&.first(3)&.join("\n           ")}"
+                ar_puts "===========================\n"
                 raise
               end
             end
@@ -250,18 +288,18 @@ module ActiveRabbit
         # In development, add a hook to verify middleware after initialization
         if Rails.env.development?
           app.config.after_initialize do
-            Rails.logger.info "\n=== ActiveRabbit Configuration ==="
-            Rails.logger.info "Version: #{ActiveRabbit::Client::VERSION}"
-            Rails.logger.info "Environment: #{Rails.env}"
-            Rails.logger.info "API URL: #{ActiveRabbit::Client.configuration.api_url}"
-            Rails.logger.info "================================"
+            ar_log(:info, "\n=== ActiveRabbit Configuration ===")
+            ar_log(:info, "Version: #{ActiveRabbit::Client::VERSION}")
+            ar_log(:info, "Environment: #{Rails.env}")
+            ar_log(:info, "API URL: #{ActiveRabbit::Client.configuration.api_url}")
+            ar_log(:info, "================================")
 
-            Rails.logger.info "\n=== Middleware Stack ==="
+            ar_log(:info, "\n=== Middleware Stack ===")
             (Rails.application.middleware.middlewares rescue []).each do |mw|
               klass = (mw.respond_to?(:klass) ? mw.klass.name : mw.to_s) rescue mw.inspect
-              Rails.logger.info "  #{klass}"
+              ar_log(:info, "  #{klass}")
             end
-            Rails.logger.info "======================="
+            ar_log(:info, "=======================")
 
             # Skip missing-middleware warnings in development since we may inject via alternate paths
             unless Rails.env.development?
@@ -284,7 +322,7 @@ module ActiveRabbit
           end
         end
 
-        Rails.logger.info "[ActiveRabbit] Middleware configured successfully"
+        ar_log(:info, "[ActiveRabbit] Middleware configured successfully")
       end
 
       initializer "active_rabbit.error_reporter" do |app|
@@ -374,8 +412,8 @@ module ActiveRabbit
           begin
             reporting_file, reporting_line = ActiveRabbit::Reporting.method(:report_exception).source_location
             http_file, http_line = ActiveRabbit::Client::HttpClient.instance_method(:post_exception).source_location
-            Rails.logger.info "[ActiveRabbit] Reporting loaded from #{reporting_file}:#{reporting_line}" if defined?(Rails)
-            Rails.logger.info "[ActiveRabbit] HttpClient#post_exception from #{http_file}:#{http_line}" if defined?(Rails)
+            ar_log(:info, "[ActiveRabbit] Reporting loaded from #{reporting_file}:#{reporting_line}") if defined?(Rails)
+            ar_log(:info, "[ActiveRabbit] HttpClient#post_exception from #{http_file}:#{http_line}") if defined?(Rails)
           rescue => e
             Rails.logger.debug "[ActiveRabbit] boot diagnostics failed: #{e.message}" if defined?(Rails)
           end
@@ -384,6 +422,34 @@ module ActiveRabbit
 
       private
 
+      def ar_puts(msg)
+        cfg = ActiveRabbit::Client.configuration
+        return if cfg && cfg.disable_console_logs
+        puts msg
+      end
+
+      def ar_log(level, msg)
+        cfg = ActiveRabbit::Client.configuration
+        return if cfg && cfg.disable_console_logs
+        Rails.logger.public_send(level, msg) if Rails.logger
+      end
+
+      def apply_rails_configuration(rails_config)
+        return unless rails_config
+
+        options = rails_config.respond_to?(:to_h) ? rails_config.to_h : rails_config
+        return if options.nil? || options.empty?
+
+        ActiveRabbit::Client.configure do |config|
+          options.each do |key, value|
+            next if value.nil?
+
+            writer = "#{key}="
+            config.public_send(writer, value) if config.respond_to?(writer)
+          end
+        end
+      end
+
       def setup_exception_tracking(app)
         # Handle uncaught exceptions in development
         if Rails.env.development? || Rails.env.test?
@@ -392,19 +458,19 @@ module ActiveRabbit
       end
 
       def subscribe_to_controller_events
-        Rails.logger.info "[ActiveRabbit] Subscribing to controller events (configured=#{ActiveRabbit::Client.configured?})"
+        ar_log(:info, "[ActiveRabbit] Subscribing to controller events (configured=#{ActiveRabbit::Client.configured?})")
 
         ActiveSupport::Notifications.subscribe "process_action.action_controller" do |name, started, finished, unique_id, payload|
           begin
             unless ActiveRabbit::Client.configured?
               Rails.logger.debug "[ActiveRabbit] Skipping performance tracking - not configured"
-              return
+              next
             end
 
             duration_ms = ((finished - started) * 1000).round(2)
 
-            Rails.logger.info "[ActiveRabbit] 📊 Controller action: #{payload[:controller]}##{payload[:action]} - #{duration_ms}ms"
-            Rails.logger.info "[ActiveRabbit] 📊 DB runtime: #{payload[:db_runtime]}, View runtime: #{payload[:view_runtime]}"
+            ar_log(:info, "[ActiveRabbit] 📊 Controller action: #{payload[:controller]}##{payload[:action]} - #{duration_ms}ms")
+            ar_log(:info, "[ActiveRabbit] 📊 DB runtime: #{payload[:db_runtime]}, View runtime: #{payload[:view_runtime]}")
 
             ActiveRabbit::Client.track_performance(
               "controller.action",
@@ -672,7 +738,7 @@ module ActiveRabbit
 
       def call(env)
         # debug start - using Rails.logger to ensure it appears in development.log
-        Rails.logger.info "[AR] ExceptionMiddleware ENTER path=#{env['PATH_INFO']}" if defined?(Rails)
+        ar_log(:info, "[AR] ExceptionMiddleware ENTER path=#{env['PATH_INFO']}") if defined?(Rails)
         warn "[AR] ExceptionMiddleware ENTER path=#{env['PATH_INFO']}"
         warn "[AR] Current exceptions in env:"
         warn "  - action_dispatch.exception: #{env['action_dispatch.exception']&.class}"
@@ -686,12 +752,12 @@ module ActiveRabbit
 
           # Check for exceptions in env after app call
           if (ex = env["action_dispatch.exception"] || env["rack.exception"] || env["action_dispatch.error"])
-            Rails.logger.info "[AR] env exception present: #{ex.class}: #{ex.message}" if defined?(Rails)
+            ar_log(:info, "[AR] env exception present: #{ex.class}: #{ex.message}") if defined?(Rails)
             warn "[AR] env exception present: #{ex.class}: #{ex.message}"
             warn "[AR] Exception backtrace: #{ex.backtrace&.first(3)&.join("\n           ")}"
             safe_report(ex, env, 'Rails rescued exception')
           else
-            Rails.logger.info "[AR] env exception NOT present" if defined?(Rails)
+            ar_log(:info, "[AR] env exception NOT present") if defined?(Rails)
             warn "[AR] env exception NOT present"
             warn "[AR] Final env check:"
             warn "  - action_dispatch.exception: #{env['action_dispatch.exception']&.class}"
@@ -703,7 +769,7 @@ module ActiveRabbit
           [status, headers, body]
         rescue => e
           # Primary path: catch raw exceptions before Rails rescuers
-          Rails.logger.info "[AR] RESCUE caught: #{e.class}: #{e.message}" if defined?(Rails)
+          ar_log(:info, "[AR] RESCUE caught: #{e.class}: #{e.message}") if defined?(Rails)
           warn "[AR] RESCUE caught: #{e.class}: #{e.message}"
           warn "[AR] Rescue backtrace: #{e.backtrace&.first(3)&.join("\n           ")}"
 
@@ -748,7 +814,7 @@ module ActiveRabbit
           result = ActiveRabbit::Client.track_exception(exception, context: context)
           warn "[AR] Track result: #{result.inspect}"
 
-          Rails.logger.info "[ActiveRabbit] Tracked #{source}: #{exception.class.name} - #{exception.message}" if defined?(Rails)
+          ar_log(:info, "[ActiveRabbit] Tracked #{source}: #{exception.class.name} - #{exception.message}") if defined?(Rails)
         rescue => tracking_error
           # Log tracking errors but don't let them interfere with exception handling
           warn "[AR] Error in safe_report: #{tracking_error.class} - #{tracking_error.message}"

data/lib/active_rabbit/client/version.rb

@@ -1,7 +1,5 @@
-# frozen_string_literal: true
-
 module ActiveRabbit
   module Client
-    VERSION = "0.4.8"
+    VERSION = "0.5.1"
   end
 end

data/lib/active_rabbit/client.rb

@@ -77,8 +77,8 @@ module ActiveRabbit
         result = exception_tracker.track_exception(**args)
 
         # Log the result
-        configuration.logger&.info("[ActiveRabbit] Exception tracked: #{exception.class.name}")
-        configuration.logger&.debug("[ActiveRabbit] Exception tracking result: #{result.inspect}")
+        ActiveRabbit::Client.log(:info, "[ActiveRabbit] Exception tracked: #{exception.class.name}")
+        ActiveRabbit::Client.log(:debug, "[ActiveRabbit] Exception tracking result: #{result.inspect}")
 
         result
       end
@@ -127,19 +127,32 @@ module ActiveRabbit
         track_exception(exception, context: context, user_id: user_id, tags: tags)
       end
 
-      def notify_deploy(project_slug:, status:, user:, version:, started_at: nil, finished_at: nil)
+      def notify_release(version: nil, environment: nil, metadata: {})
+        return unless configured?
+
+        cfg = configuration
+        version ||= cfg.revision || cfg.release
+        environment ||= cfg.environment
+        return if version.nil? || version.to_s.strip.empty?
+
         payload = {
-          revision: Client.configuration.revision,
-          environment: Client.configuration.environment,
-          project_slug: project_slug,
           version: version,
-          status: status,
-          user: user,
-          started_at: started_at,
-          finished_at: finished_at
+          environment: environment,
+          metadata: metadata || {}
         }
 
-        http_client.post("/api/v1/deploys", payload)
+        http_client.post_release(payload)
+      end
+
+      def log(level, message)
+        cfg = configuration
+        return if cfg.nil? || cfg.disable_console_logs
+
+        case level
+        when :info  then cfg.logger&.info(message)
+        when :debug then cfg.logger&.debug(message)
+        when :error then cfg.logger&.error(message)
+        end
       end
 
       private

data/lib/active_rabbit/middleware/error_capture_middleware.rb

@@ -13,7 +13,7 @@ module ActiveRabbit
         begin
           ActiveRabbit::Reporting.report_exception(e, env: env, handled: false, source: "middleware", force: true)
         rescue => inner
-          Rails.logger&.error("[ActiveRabbit] ErrorCaptureMiddleware failed: #{inner.class}: #{inner.message}") if defined?(Rails)
+          ActiveRabbit::Client.log(:error, "[ActiveRabbit] ErrorCaptureMiddleware failed: #{inner.class}: #{inner.message}")
         end
         raise
       end

data/lib/active_rabbit/reporting.rb

@@ -40,7 +40,7 @@ module ActiveRabbit
         force: force)
     rescue => e
       if defined?(Rails)
-        Rails.logger&.error("[ActiveRabbit] report_exception failed: #{e.class}: #{e.message}")
+        ActiveRabbit::Client.log(:error, "[ActiveRabbit] report_exception failed: #{e.class}: #{e.message}")
       end
       nil
     end

data/lib/active_rabbit/routing/not_found_app.rb

@@ -8,7 +8,7 @@ module ActiveRabbit
         begin
           ActiveRabbit::Reporting.report_exception(error, env: env, handled: true, source: "router", force: true)
         rescue => e
-          Rails.logger&.error("[ActiveRabbit] NotFoundApp failed to report: #{e.class}: #{e.message}") if defined?(Rails)
+          ActiveRabbit::Client.log(:error, "[ActiveRabbit] NotFoundApp failed to report: #{e.class}: #{e.message}")
         end
         [404, { "Content-Type" => "text/plain" }, ["Not Found"]]
       end

data/script/test_production_readiness.rb

@@ -14,9 +14,9 @@ puts "🚀 ActiveRabbit Production Readiness Test"
 puts "=" * 50
 
 # Test configuration
-TEST_API_KEY = ENV['active_rabbit_API_KEY'] || 'test-key-for-validation'
-TEST_PROJECT_ID = ENV['active_rabbit_PROJECT_ID'] || 'test-project'
-TEST_API_URL = ENV['active_rabbit_API_URL'] || 'https://api.activerabbit.com'
+TEST_API_KEY = ENV['ACTIVERABBIT_API_KEY'] || 'test-key-for-validation'
+TEST_PROJECT_ID = ENV['ACTIVERABBIT_PROJECT_ID'] || 'test-project'
+TEST_API_URL = ENV['ACTIVERABBIT_API_URL'] || 'https://api.activerabbit.com'
 
 # Load the gem
 begin
@@ -374,7 +374,7 @@ puts "=" * 50
 
 if TEST_API_KEY == 'test-key-for-validation'
   puts "⚠️  Note: Tests run with mock configuration"
-  puts "   Set active_rabbit_API_KEY and active_rabbit_PROJECT_ID"
+  puts "   Set ACTIVERABBIT_API_KEY and ACTIVERABBIT_PROJECT_ID"
   puts "   environment variables for full integration testing"
 else
   puts "✅ Full integration test completed with real API"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerabbit-ai
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.5.1
 platform: ruby
 authors:
 - Alex Shapalov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-27 00:00:00.000000000 Z
+date: 2025-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -86,7 +86,6 @@ files:
 - examples/rails_app_testing.rb
 - examples/rails_integration.rb
 - examples/standalone_usage.rb
-- lib/active_rabbit-client.gemspec
 - lib/active_rabbit.rb
 - lib/active_rabbit/client.rb
 - lib/active_rabbit/client/action_mailer_patch.rb