fluyenta-ruby 0.1.14

data/lib/brainzlab/flux/provisioner.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'fileutils'
+
+module BrainzLab
+  module Flux
+    class Provisioner
+      CACHE_DIR = ENV.fetch('BRAINZLAB_CACHE_DIR') { File.join(Dir.home, '.brainzlab') }
+
+      def initialize(config)
+        @config = config
+      end
+
+      def ensure_project!
+        return unless should_provision?
+
+        # Try cached credentials first
+        if (cached = load_cached_credentials)
+          apply_credentials(cached)
+          return cached
+        end
+
+        # Provision new project
+        project = provision_project
+        return unless project
+
+        # Cache and apply credentials
+        cache_credentials(project)
+        apply_credentials(project)
+
+        project
+      end
+
+      private
+
+      def should_provision?
+        # Already have credentials
+        return false if @config.flux_ingest_key.to_s.strip.length.positive?
+        return false if @config.flux_api_key.to_s.strip.length.positive?
+
+        # Need auto_provision enabled
+        return false unless @config.flux_auto_provision
+
+        # Need app_name for project name
+        return false unless @config.app_name.to_s.strip.length.positive?
+
+        # Need master key for provisioning
+        return false unless @config.flux_master_key.to_s.strip.length.positive?
+
+        # Need flux_url
+        return false unless @config.flux_url.to_s.strip.length.positive?
+
+        true
+      end
+
+      def provision_project
+        BrainzLab.debug_log('[Flux] Auto-provisioning project...')
+
+        uri = URI.parse("#{@config.flux_url}/api/v1/projects/provision")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 5
+        http.read_timeout = 10
+
+        request = Net::HTTP::Post.new(uri.path)
+        request['Content-Type'] = 'application/json'
+        request['X-Master-Key'] = @config.flux_master_key
+        request['User-Agent'] = "brainzlab-sdk/#{BrainzLab::VERSION}"
+        request.body = {
+          name: @config.app_name,
+          environment: @config.environment
+        }.to_json
+
+        response = http.request(request)
+
+        if response.is_a?(Net::HTTPSuccess)
+          data = JSON.parse(response.body, symbolize_names: true)
+          BrainzLab.debug_log('[Flux] Project provisioned successfully')
+          data
+        else
+          BrainzLab.debug_log("[Flux] Provisioning failed: #{response.code} - #{response.body}")
+          nil
+        end
+      rescue StandardError => e
+        BrainzLab.debug_log("[Flux] Provisioning error: #{e.message}")
+        nil
+      end
+
+      def load_cached_credentials
+        path = cache_file_path
+        return nil unless File.exist?(path)
+
+        data = JSON.parse(File.read(path), symbolize_names: true)
+
+        # Validate cached data has required keys
+        return nil unless data[:ingest_key]
+
+        data
+      rescue StandardError => e
+        BrainzLab.debug_log("[Flux] Failed to load cached credentials: #{e.message}")
+        nil
+      end
+
+      def cache_credentials(project)
+        FileUtils.mkdir_p(CACHE_DIR)
+        File.write(cache_file_path, JSON.generate(project))
+      rescue StandardError => e
+        BrainzLab.debug_log("[Flux] Failed to cache credentials: #{e.message}")
+      end
+
+      def cache_file_path
+        File.join(CACHE_DIR, "#{@config.app_name}.flux.json")
+      end
+
+      def apply_credentials(project)
+        @config.flux_ingest_key = project[:ingest_key]
+        @config.flux_api_key = project[:api_key]
+      end
+    end
+  end
+end

data/lib/brainzlab/flux.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative 'flux/client'
+require_relative 'flux/buffer'
+require_relative 'flux/provisioner'
+
+module BrainzLab
+  module Flux
+    class << self
+      # === EVENTS ===
+
+      # Track a custom event
+      # @param name [String] Event name (e.g., 'user.signup', 'order.completed')
+      # @param properties [Hash] Event properties
+      def track(name, properties = {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        event = {
+          name: name,
+          timestamp: Time.now.utc.iso8601(3),
+          properties: properties.except(:user_id, :value, :tags, :session_id),
+          user_id: properties[:user_id],
+          session_id: properties[:session_id],
+          value: properties[:value],
+          tags: properties[:tags] || {},
+          environment: BrainzLab.configuration.environment,
+          service: BrainzLab.configuration.service
+        }
+
+        buffer.add(:event, event)
+      end
+
+      # Track event for a specific user
+      def track_for_user(user, name, properties = {})
+        user_id = user.respond_to?(:id) ? user.id.to_s : user.to_s
+        track(name, properties.merge(user_id: user_id))
+      end
+
+      # === METRICS ===
+
+      # Gauge: Current value (overwrites)
+      def gauge(name, value, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'gauge',
+          name: name,
+          value: value,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # Counter: Increment value
+      def increment(name, value = 1, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'counter',
+          name: name,
+          value: value,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # Counter: Decrement value
+      def decrement(name, value = 1, tags: {})
+        increment(name, -value, tags: tags)
+      end
+
+      # Distribution: Statistical aggregation
+      def distribution(name, value, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'distribution',
+          name: name,
+          value: value,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # Histogram: Alias for distribution (for compatibility with brainzlab-rails)
+      def histogram(name, value, tags: {})
+        distribution(name, value, tags: tags)
+      end
+
+      # Timing: Record duration in milliseconds (alias for distribution)
+      def timing(name, value_ms, tags: {})
+        distribution(name, value_ms, tags: tags.merge(unit: 'ms'))
+      end
+
+      # Set: Unique count (cardinality)
+      def set(name, value, tags: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.flux_valid?
+
+        metric = {
+          type: 'set',
+          name: name,
+          value: value.to_s,
+          tags: tags,
+          timestamp: Time.now.utc.iso8601(3)
+        }
+
+        buffer.add(:metric, metric)
+      end
+
+      # === CONVENIENCE METHODS ===
+
+      # Time a block and record as distribution
+      def measure(name, tags: {})
+        start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        begin
+          yield
+        ensure
+          duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000
+          distribution(name, duration_ms, tags: tags.merge(unit: 'ms'))
+        end
+      end
+
+      # Flush any buffered data immediately
+      def flush!
+        buffer.flush!
+      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 buffer
+        @buffer ||= Buffer.new(client)
+      end
+
+      def reset!
+        @client = nil
+        @buffer = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.flux_effectively_enabled?
+      end
+    end
+  end
+end

data/lib/brainzlab/instrumentation/action_cable.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Instrumentation
+    class ActionCable
+      # Thresholds for slow operations (in milliseconds)
+      SLOW_ACTION_THRESHOLD = 100
+      VERY_SLOW_ACTION_THRESHOLD = 500
+
+      class << self
+        def install!
+          return unless defined?(::ActionCable)
+          return if @installed
+
+          install_perform_action_subscriber!
+          install_transmit_subscriber!
+          install_transmit_subscription_confirmation_subscriber!
+          install_transmit_subscription_rejection_subscriber!
+          install_broadcast_subscriber!
+
+          @installed = true
+          BrainzLab.debug_log('ActionCable instrumentation installed')
+        end
+
+        def installed?
+          @installed == true
+        end
+
+        private
+
+        # ============================================
+        # perform_action.action_cable
+        # ============================================
+        def install_perform_action_subscriber!
+          ActiveSupport::Notifications.subscribe('perform_action.action_cable') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_perform_action(event)
+          end
+        end
+
+        def handle_perform_action(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          channel_class = payload[:channel_class]
+          action = payload[:action]
+          data = payload[:data]
+
+          # Determine level based on duration
+          level = case duration
+                  when 0...SLOW_ACTION_THRESHOLD then :info
+                  when SLOW_ACTION_THRESHOLD...VERY_SLOW_ACTION_THRESHOLD then :warning
+                  else :error
+                  end
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Cable action: #{channel_class}##{action} (#{duration}ms)",
+              category: 'cable.action',
+              level: level,
+              data: {
+                channel: channel_class,
+                action: action,
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_action_span(event, channel_class, action, duration, data)
+
+          # Log slow actions
+          log_slow_action(channel_class, action, duration) if duration >= SLOW_ACTION_THRESHOLD
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionCable perform_action instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # transmit.action_cable
+        # ============================================
+        def install_transmit_subscriber!
+          ActiveSupport::Notifications.subscribe('transmit.action_cable') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_transmit(event)
+          end
+        end
+
+        def handle_transmit(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          channel_class = payload[:channel_class]
+          data = payload[:data]
+          via = payload[:via]
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            message = via ? "Cable transmit via #{via}" : 'Cable transmit'
+            BrainzLab::Reflex.add_breadcrumb(
+              "#{message}: #{channel_class} (#{duration}ms)",
+              category: 'cable.transmit',
+              level: :info,
+              data: {
+                channel: channel_class,
+                via: via,
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_transmit_span(event, channel_class, duration, via)
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionCable transmit instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # transmit_subscription_confirmation.action_cable
+        # ============================================
+        def install_transmit_subscription_confirmation_subscriber!
+          ActiveSupport::Notifications.subscribe('transmit_subscription_confirmation.action_cable') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_subscription_confirmation(event)
+          end
+        end
+
+        def handle_subscription_confirmation(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          channel_class = payload[:channel_class]
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Cable subscribed: #{channel_class}",
+              category: 'cable.subscribe',
+              level: :info,
+              data: {
+                channel: channel_class,
+                status: 'confirmed',
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_subscription_span(event, channel_class, 'confirmed', duration)
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionCable subscription confirmation instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # transmit_subscription_rejection.action_cable
+        # ============================================
+        def install_transmit_subscription_rejection_subscriber!
+          ActiveSupport::Notifications.subscribe('transmit_subscription_rejection.action_cable') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_subscription_rejection(event)
+          end
+        end
+
+        def handle_subscription_rejection(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          channel_class = payload[:channel_class]
+
+          # Record breadcrumb - rejection is a warning
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Cable subscription rejected: #{channel_class}",
+              category: 'cable.subscribe',
+              level: :warning,
+              data: {
+                channel: channel_class,
+                status: 'rejected',
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_subscription_span(event, channel_class, 'rejected', duration)
+
+          # Log rejection to Recall
+          if BrainzLab.configuration.recall_effectively_enabled?
+            BrainzLab::Recall.warn(
+              "ActionCable subscription rejected",
+              channel: channel_class
+            )
+          end
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionCable subscription rejection instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # broadcast.action_cable
+        # ============================================
+        def install_broadcast_subscriber!
+          ActiveSupport::Notifications.subscribe('broadcast.action_cable') do |*args|
+            event = ActiveSupport::Notifications::Event.new(*args)
+            handle_broadcast(event)
+          end
+        end
+
+        def handle_broadcast(event)
+          payload = event.payload
+          duration = event.duration.round(2)
+
+          broadcasting = payload[:broadcasting]
+          message = payload[:message]
+          coder = payload[:coder]
+
+          # Record breadcrumb
+          if BrainzLab.configuration.reflex_effectively_enabled?
+            BrainzLab::Reflex.add_breadcrumb(
+              "Cable broadcast: #{broadcasting} (#{duration}ms)",
+              category: 'cable.broadcast',
+              level: :info,
+              data: {
+                broadcasting: broadcasting,
+                coder: coder&.to_s,
+                duration_ms: duration
+              }.compact
+            )
+          end
+
+          # Add Pulse span
+          record_broadcast_span(event, broadcasting, duration, coder)
+        rescue StandardError => e
+          BrainzLab.debug_log("ActionCable broadcast instrumentation failed: #{e.message}")
+        end
+
+        # ============================================
+        # Span Recording Helpers
+        # ============================================
+        def record_action_span(event, channel_class, action, duration, data)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: "cable.action.#{action}",
+            kind: 'websocket',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: false,
+            data: {
+              'cable.channel' => channel_class,
+              'cable.action' => action
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        def record_transmit_span(event, channel_class, duration, via)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: 'cable.transmit',
+            kind: 'websocket',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: false,
+            data: {
+              'cable.channel' => channel_class,
+              'cable.via' => via
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        def record_subscription_span(event, channel_class, status, duration)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: 'cable.subscribe',
+            kind: 'websocket',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: status == 'rejected',
+            data: {
+              'cable.channel' => channel_class,
+              'cable.subscription_status' => status
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        def record_broadcast_span(event, broadcasting, duration, coder)
+          return unless BrainzLab.configuration.pulse_effectively_enabled?
+
+          tracer = BrainzLab::Pulse.tracer
+          return unless tracer.current_trace
+
+          span_data = {
+            span_id: SecureRandom.uuid,
+            name: 'cable.broadcast',
+            kind: 'websocket',
+            started_at: event.time,
+            ended_at: event.end,
+            duration_ms: duration,
+            error: false,
+            data: {
+              'cable.broadcasting' => broadcasting,
+              'cable.coder' => coder&.to_s
+            }.compact
+          }
+
+          tracer.current_spans << span_data
+        end
+
+        # ============================================
+        # Logging Helpers
+        # ============================================
+        def log_slow_action(channel_class, action, duration)
+          return unless BrainzLab.configuration.recall_effectively_enabled?
+
+          level = duration >= VERY_SLOW_ACTION_THRESHOLD ? :error : :warn
+
+          BrainzLab::Recall.send(
+            level,
+            "Slow ActionCable action: #{channel_class}##{action} (#{duration}ms)",
+            channel: channel_class,
+            action: action,
+            duration_ms: duration,
+            threshold_exceeded: duration >= VERY_SLOW_ACTION_THRESHOLD ? 'critical' : 'warning'
+          )
+        end
+      end
+    end
+  end
+end