brainzlab 0.1.0 → 0.1.2

data/lib/brainzlab/sentinel/client.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module BrainzLab
+  module Sentinel
+    class Client
+      def initialize(config)
+        @config = config
+        @base_url = config.sentinel_url || "https://sentinel.brainzlab.ai"
+      end
+
+      # List all registered hosts
+      def list_hosts(status: nil, page: 1, per_page: 50)
+        params = { page: page, per_page: per_page }
+        params[:status] = status if status
+
+        response = request(:get, "/api/v1/hosts", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:hosts] || []
+      rescue StandardError => e
+        log_error("list_hosts", e)
+        []
+      end
+
+      # Get host details
+      def get_host(host_id)
+        response = request(:get, "/api/v1/hosts/#{host_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_host", e)
+        nil
+      end
+
+      # Get host metrics
+      # @param host_id [String] Host ID
+      # @param period [String] Time period (1h, 6h, 24h, 7d, 30d)
+      # @param metrics [Array<String>] Specific metrics to fetch (cpu, memory, disk, network)
+      def get_metrics(host_id, period: "1h", metrics: nil)
+        params = { period: period }
+        params[:metrics] = metrics.join(",") if metrics
+
+        response = request(:get, "/api/v1/hosts/#{host_id}/metrics", params: params)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_metrics", e)
+        nil
+      end
+
+      # Get top processes for a host
+      def get_processes(host_id, sort_by: "cpu", limit: 20)
+        params = { sort_by: sort_by, limit: limit }
+
+        response = request(:get, "/api/v1/hosts/#{host_id}/processes", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:processes] || []
+      rescue StandardError => e
+        log_error("get_processes", e)
+        []
+      end
+
+      # List all containers
+      def list_containers(host_id: nil, status: nil)
+        params = {}
+        params[:host_id] = host_id if host_id
+        params[:status] = status if status
+
+        response = request(:get, "/api/v1/containers", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:containers] || []
+      rescue StandardError => e
+        log_error("list_containers", e)
+        []
+      end
+
+      # Get container details
+      def get_container(container_id)
+        response = request(:get, "/api/v1/containers/#{container_id}")
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_container", e)
+        nil
+      end
+
+      # Get container metrics
+      def get_container_metrics(container_id, period: "1h")
+        params = { period: period }
+
+        response = request(:get, "/api/v1/containers/#{container_id}/metrics", params: params)
+
+        return nil unless response.is_a?(Net::HTTPSuccess)
+
+        JSON.parse(response.body, symbolize_names: true)
+      rescue StandardError => e
+        log_error("get_container_metrics", e)
+        nil
+      end
+
+      # Get alerts for a host
+      def get_alerts(host_id: nil, status: nil, severity: nil)
+        params = {}
+        params[:host_id] = host_id if host_id
+        params[:status] = status if status
+        params[:severity] = severity if severity
+
+        response = request(:get, "/api/v1/alerts", params: params)
+
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        data = JSON.parse(response.body, symbolize_names: true)
+        data[:alerts] || []
+      rescue StandardError => e
+        log_error("get_alerts", e)
+        []
+      end
+
+      # Report metrics from agent (internal use)
+      def report_metrics(host_id:, metrics:, timestamp: nil)
+        response = request(
+          :post,
+          "/internal/agent/report",
+          body: {
+            host_id: host_id,
+            metrics: metrics,
+            timestamp: timestamp || Time.now.utc.iso8601
+          },
+          use_agent_key: true
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPAccepted)
+      rescue StandardError => e
+        log_error("report_metrics", e)
+        false
+      end
+
+      def provision(project_id:, app_name:)
+        response = request(
+          :post,
+          "/api/v1/projects/provision",
+          body: { project_id: project_id, app_name: app_name },
+          use_service_key: true
+        )
+
+        response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPCreated)
+      rescue StandardError => e
+        log_error("provision", e)
+        false
+      end
+
+      private
+
+      def request(method, path, headers: {}, body: nil, params: nil, use_service_key: false, use_agent_key: false)
+        uri = URI.parse("#{@base_url}#{path}")
+
+        if params
+          uri.query = URI.encode_www_form(params)
+        end
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        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"
+
+        if use_service_key
+          request["X-Service-Key"] = @config.sentinel_master_key || @config.secret_key
+        elsif use_agent_key
+          request["X-Agent-Key"] = @config.sentinel_agent_key || @config.sentinel_api_key || @config.secret_key
+        else
+          auth_key = @config.sentinel_api_key || @config.secret_key
+          request["Authorization"] = "Bearer #{auth_key}" if auth_key
+        end
+
+        headers.each { |k, v| request[k] = v }
+        request.body = body.to_json if body
+
+        http.request(request)
+      end
+
+      def log_error(operation, error)
+        BrainzLab.debug_log("[Sentinel::Client] #{operation} failed: #{error.message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/sentinel/provisioner.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BrainzLab
+  module Sentinel
+    class Provisioner
+      def initialize(config)
+        @config = config
+        @provisioned = false
+      end
+
+      def ensure_project!
+        return if @provisioned
+        return unless @config.sentinel_auto_provision
+        return unless valid_auth?
+
+        @provisioned = true
+
+        project_id = detect_project_id
+        return unless project_id
+
+        client = Client.new(@config)
+        client.provision(
+          project_id: project_id,
+          app_name: @config.app_name || @config.service
+        )
+
+        BrainzLab.debug_log("[Sentinel::Provisioner] Project provisioned: #{project_id}")
+      rescue StandardError => e
+        BrainzLab.debug_log("[Sentinel::Provisioner] Provisioning failed: #{e.message}")
+      end
+
+      private
+
+      def valid_auth?
+        key = @config.sentinel_api_key || @config.sentinel_master_key || @config.secret_key
+        !key.nil? && !key.empty?
+      end
+
+      def detect_project_id
+        ENV["BRAINZLAB_PROJECT_ID"]
+      end
+    end
+  end
+end

data/lib/brainzlab/sentinel.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "sentinel/client"
+require_relative "sentinel/provisioner"
+
+module BrainzLab
+  module Sentinel
+    class << self
+      # List all registered hosts
+      # @param status [String] Filter by status (online, offline, warning, critical)
+      # @param page [Integer] Page number
+      # @param per_page [Integer] Results per page
+      # @return [Array<Hash>] List of hosts
+      #
+      # @example
+      #   hosts = BrainzLab::Sentinel.hosts(status: "online")
+      #
+      def hosts(status: nil, page: 1, per_page: 50)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.sentinel_valid?
+
+        client.list_hosts(status: status, page: page, per_page: per_page)
+      end
+
+      # Get host details
+      # @param host_id [String] Host ID
+      # @return [Hash, nil] Host details
+      def host(host_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.sentinel_valid?
+
+        client.get_host(host_id)
+      end
+
+      # Get metrics for a host
+      # @param host_id [String] Host ID
+      # @param period [String] Time period (1h, 6h, 24h, 7d, 30d)
+      # @param metrics [Array<String>] Specific metrics (cpu, memory, disk, network)
+      # @return [Hash, nil] Metrics data
+      #
+      # @example
+      #   metrics = BrainzLab::Sentinel.metrics(host_id, period: "24h", metrics: ["cpu", "memory"])
+      #
+      def metrics(host_id, period: "1h", metrics: nil)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.sentinel_valid?
+
+        client.get_metrics(host_id, period: period, metrics: metrics)
+      end
+
+      # Get top processes for a host
+      # @param host_id [String] Host ID
+      # @param sort_by [String] Sort by (cpu, memory, time)
+      # @param limit [Integer] Max results
+      # @return [Array<Hash>] Process list
+      #
+      # @example
+      #   procs = BrainzLab::Sentinel.processes(host_id, sort_by: "memory", limit: 10)
+      #
+      def processes(host_id, sort_by: "cpu", limit: 20)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.sentinel_valid?
+
+        client.get_processes(host_id, sort_by: sort_by, limit: limit)
+      end
+
+      # List all containers
+      # @param host_id [String] Optional filter by host
+      # @param status [String] Filter by status (running, stopped, paused)
+      # @return [Array<Hash>] Container list
+      #
+      # @example
+      #   containers = BrainzLab::Sentinel.containers(host_id: "host_123", status: "running")
+      #
+      def containers(host_id: nil, status: nil)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.sentinel_valid?
+
+        client.list_containers(host_id: host_id, status: status)
+      end
+
+      # Get container details
+      # @param container_id [String] Container ID
+      # @return [Hash, nil] Container details
+      def container(container_id)
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.sentinel_valid?
+
+        client.get_container(container_id)
+      end
+
+      # Get container metrics
+      # @param container_id [String] Container ID
+      # @param period [String] Time period
+      # @return [Hash, nil] Container metrics
+      def container_metrics(container_id, period: "1h")
+        return nil unless enabled?
+
+        ensure_provisioned!
+        return nil unless BrainzLab.configuration.sentinel_valid?
+
+        client.get_container_metrics(container_id, period: period)
+      end
+
+      # Get alerts
+      # @param host_id [String] Optional filter by host
+      # @param status [String] Filter by status (active, acknowledged, resolved)
+      # @param severity [String] Filter by severity (info, warning, critical)
+      # @return [Array<Hash>] Alert list
+      #
+      # @example
+      #   alerts = BrainzLab::Sentinel.alerts(severity: "critical", status: "active")
+      #
+      def alerts(host_id: nil, status: nil, severity: nil)
+        return [] unless enabled?
+
+        ensure_provisioned!
+        return [] unless BrainzLab.configuration.sentinel_valid?
+
+        client.get_alerts(host_id: host_id, status: status, severity: severity)
+      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 reset!
+        @client = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.sentinel_enabled
+      end
+    end
+  end
+end

data/lib/brainzlab/signal/client.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module BrainzLab
+  module Signal
+    class Client
+      def initialize(config)
+        @config = config
+      end
+
+      def send_alert(alert)
+        post("/api/v1/alerts", alert)
+      end
+
+      def send_notification(notification)
+        post("/api/v1/notifications", notification)
+      end
+
+      def trigger_rule(payload)
+        post("/api/v1/rules/trigger", payload)
+      end
+
+      private
+
+      def post(path, body)
+        uri = URI.parse("#{base_url}#{path}")
+        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["Authorization"] = "Bearer #{api_key}"
+        request["User-Agent"] = "brainzlab-sdk/#{BrainzLab::VERSION}"
+        request.body = body.to_json
+
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          BrainzLab.debug_log("[Signal] Request failed: #{response.code} - #{response.body}")
+        end
+
+        response
+      rescue => e
+        BrainzLab.debug_log("[Signal] Request error: #{e.message}")
+        nil
+      end
+
+      def base_url
+        @config.signal_url
+      end
+
+      def api_key
+        @config.signal_auth_key
+      end
+    end
+  end
+end

data/lib/brainzlab/signal/provisioner.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module BrainzLab
+  module Signal
+    class Provisioner
+      def initialize(config)
+        @config = config
+      end
+
+      def ensure_project!
+        return if @config.signal_api_key && !@config.signal_api_key.to_s.empty?
+        return unless @config.signal_url && !@config.signal_url.to_s.empty?
+        return unless @config.secret_key && !@config.secret_key.to_s.empty?
+
+        BrainzLab.debug_log("[Signal] Auto-provisioning project...")
+        provision_project
+      end
+
+      private
+
+      def provision_project
+        uri = URI.parse("#{@config.signal_url}/api/v1/projects/provision")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = 10
+        http.read_timeout = 30
+
+        request = Net::HTTP::Post.new(uri.path)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{@config.secret_key}"
+        request["User-Agent"] = "brainzlab-sdk/#{BrainzLab::VERSION}"
+        request.body = {
+          name: @config.service || "default",
+          environment: @config.environment
+        }.to_json
+
+        response = http.request(request)
+
+        if response.is_a?(Net::HTTPSuccess)
+          data = JSON.parse(response.body)
+          @config.signal_api_key = data["api_key"]
+          BrainzLab.debug_log("[Signal] Project provisioned successfully")
+        else
+          BrainzLab.debug_log("[Signal] Provisioning failed: #{response.code} - #{response.body}")
+        end
+      rescue => e
+        BrainzLab.debug_log("[Signal] Provisioning error: #{e.message}")
+      end
+    end
+  end
+end

data/lib/brainzlab/signal.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "signal/client"
+require_relative "signal/provisioner"
+
+module BrainzLab
+  module Signal
+    SEVERITIES = %i[info warning error critical].freeze
+
+    class << self
+      # Send an alert with a message
+      # @param name [String] Alert name (e.g., 'high_error_rate', 'low_disk_space')
+      # @param message [String] Alert message
+      # @param severity [Symbol] Alert severity (:info, :warning, :error, :critical)
+      # @param channels [Array<String>] Channels to send alert to (e.g., ['slack', 'email'])
+      # @param data [Hash] Additional data to include with the alert
+      def alert(name, message, severity: :warning, channels: nil, data: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.signal_valid?
+
+        payload = {
+          type: "alert",
+          name: name,
+          message: message,
+          severity: severity.to_s,
+          channels: channels,
+          data: data,
+          timestamp: Time.now.utc.iso8601(3),
+          environment: BrainzLab.configuration.environment,
+          service: BrainzLab.configuration.service,
+          host: BrainzLab.configuration.host,
+          context: context_data
+        }
+
+        client.send_alert(payload)
+      end
+
+      # Send a notification to specific channels
+      # @param channel [String, Array<String>] Channel(s) to send to ('slack', 'email', 'webhook')
+      # @param message [String] Notification message
+      # @param title [String] Optional notification title
+      # @param data [Hash] Additional data
+      def notify(channel, message, title: nil, data: {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.signal_valid?
+
+        channels = Array(channel)
+        payload = {
+          type: "notification",
+          channels: channels,
+          message: message,
+          title: title,
+          data: data,
+          timestamp: Time.now.utc.iso8601(3),
+          environment: BrainzLab.configuration.environment,
+          service: BrainzLab.configuration.service
+        }
+
+        client.send_notification(payload)
+      end
+
+      # Trigger a predefined alert rule
+      # @param rule_name [String] Name of the alert rule to trigger
+      # @param context [Hash] Context data to pass to the rule
+      def trigger(rule_name, context = {})
+        return unless enabled?
+
+        ensure_provisioned!
+        return unless BrainzLab.configuration.signal_valid?
+
+        payload = {
+          type: "trigger",
+          rule: rule_name,
+          context: context,
+          timestamp: Time.now.utc.iso8601(3),
+          environment: BrainzLab.configuration.environment,
+          service: BrainzLab.configuration.service
+        }
+
+        client.trigger_rule(payload)
+      end
+
+      # Send a test alert to verify configuration
+      def test!
+        alert(
+          "test_alert",
+          "This is a test alert from BrainzLab Signal SDK",
+          severity: :info,
+          data: { test: true, sdk_version: BrainzLab::VERSION }
+        )
+      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 reset!
+        @client = nil
+        @provisioner = nil
+        @provisioned = false
+      end
+
+      private
+
+      def enabled?
+        BrainzLab.configuration.signal_effectively_enabled?
+      end
+
+      def context_data
+        ctx = BrainzLab::Context.current
+        {
+          user: ctx.user,
+          tags: ctx.tags,
+          extra: ctx.extra
+        }
+      end
+    end
+  end
+end