allstak 0.1.1

data/lib/allstak/integrations/net_http.rb

@@ -0,0 +1,87 @@
+require "net/http"
+
+module AllStak
+  module Integrations
+    # Monkey-patches Net::HTTP#request to capture outbound HTTP calls as
+    # AllStak http-request telemetry with real timing, status, and size.
+    #
+    # No duplication: we patch at the #request level, which every Net::HTTP
+    # convenience method (get, post, post_form, etc.) funnels through.
+    module NetHTTP
+      def self.install!
+        return if @installed
+        ::Net::HTTP.prepend(Patch)
+        @installed = true
+      end
+
+      def self.installed?
+        @installed == true
+      end
+
+      module Patch
+        def request(req, body = nil, &block)
+          return super unless AllStak.initialized?
+
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          host = (req["Host"] || address).to_s
+          path = begin
+            req.path.to_s
+          rescue
+            "/"
+          end
+          method = req.method.to_s.upcase
+          status = 0
+          resp_size = 0
+          req_size = req.body.to_s.bytesize rescue 0
+          error_fp = nil
+
+          client = AllStak.client
+          # Short-circuit: do NOT instrument our own ingest calls
+          return super if host.include?("ingest") || host_matches_allstak?(host)
+
+          begin
+            response = super
+            status = response.code.to_i
+            resp_size = response.body.to_s.bytesize rescue 0
+            response
+          rescue => e
+            error_fp = e.class.name
+            raise
+          ensure
+            begin
+              duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).to_i
+              client.http.record(
+                direction: "outbound",
+                method: method,
+                host: host,
+                path: path,
+                status_code: status,
+                duration_ms: duration,
+                request_size: req_size,
+                response_size: resp_size,
+                trace_id: client.tracing.current_trace_id,
+                error_fingerprint: error_fp
+              )
+            rescue
+              # never raise into host
+            end
+          end
+        end
+
+        private
+
+        def host_matches_allstak?(h)
+          return false unless AllStak.initialized?
+          base = AllStak.client.config.host.to_s
+          return false if base.empty?
+          begin
+            uri = URI.parse(base)
+            !!(uri.host && h.include?(uri.host))
+          rescue
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/allstak/integrations/rack.rb

@@ -0,0 +1,136 @@
+module AllStak
+  module Integrations
+    module Rack
+      # Rack middleware that:
+      # 1. Starts a fresh trace per request (or adopts X-AllStak-Trace-Id / traceparent)
+      # 2. Captures inbound HTTP request telemetry
+      # 3. Auto-captures unhandled exceptions with full request context, user, stack, and trace link
+      # 4. Re-raises so the framework's exception handler runs
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          return @app.call(env) unless AllStak.initialized?
+
+          client = AllStak.client
+          config = client.config
+
+          start = now_ms
+          started_at = Time.now.utc.iso8601(3)
+
+          # Trace id — adopt incoming or mint fresh per request
+          incoming = env["HTTP_X_ALLSTAK_TRACE_ID"] || env["HTTP_TRACEPARENT"]
+          if incoming && !incoming.empty?
+            client.tracing.set_trace_id(incoming)
+          else
+            client.tracing.reset_trace
+          end
+          trace_id = client.tracing.current_trace_id
+
+          status = 0
+          headers = {}
+          body = nil
+          captured = nil
+
+          begin
+            status, headers, body = @app.call(env)
+          rescue => e
+            captured = e
+            status = 500 if status.to_i == 0
+            raise
+          ensure
+            duration = now_ms - start
+
+            # Request telemetry
+            if config.capture_http_requests
+              begin
+                req_size = env["CONTENT_LENGTH"].to_i
+                resp_size = headers && headers["Content-Length"].to_i
+                user_id = extract_user_id(env)
+                path = env["PATH_INFO"] || "/"
+
+                client.http.record(
+                  direction: "inbound",
+                  method: env["REQUEST_METHOD"] || "GET",
+                  host: env["HTTP_HOST"] || "localhost",
+                  path: path,
+                  status_code: status.to_i,
+                  duration_ms: duration,
+                  request_size: req_size,
+                  response_size: resp_size || 0,
+                  trace_id: trace_id,
+                  user_id: user_id
+                )
+              rescue => err
+                # never raise into host
+                config.debug && warn("[AllStak] rack request capture failed: #{err.message}")
+              end
+            end
+
+            # Exception capture
+            if captured && config.capture_unhandled_exceptions
+              begin
+                user_ctx = config.capture_user_context ? build_user_context(env) : nil
+                req_ctx = AllStak::Models::RequestContext.new(
+                  method: env["REQUEST_METHOD"],
+                  path: env["PATH_INFO"],
+                  host: env["HTTP_HOST"],
+                  status_code: status.to_i == 0 ? 500 : status.to_i,
+                  user_agent: env["HTTP_USER_AGENT"]
+                )
+                meta = {
+                  "http.method" => env["REQUEST_METHOD"],
+                  "http.path"   => env["PATH_INFO"],
+                  "http.host"   => env["HTTP_HOST"],
+                  "http.status" => status.to_i == 0 ? 500 : status.to_i,
+                  "traceId"     => trace_id
+                }
+                client.errors.capture_exception(
+                  captured,
+                  user: user_ctx,
+                  request_context: req_ctx,
+                  trace_id: trace_id,
+                  metadata: meta
+                )
+              rescue => err
+                config.debug && warn("[AllStak] rack exception capture failed: #{err.message}")
+              end
+            end
+
+            # Best-effort response header for downstream trace linkage
+            headers["X-AllStak-Trace-Id"] = trace_id if headers && !captured
+          end
+
+          [status, headers, body]
+        end
+
+        private
+
+        def now_ms
+          (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i
+        end
+
+        def extract_user_id(env)
+          # Rack-standard: env["warden"]? env["rack.session"]?
+          # Apps can set env["allstak.user_id"] directly.
+          return env["allstak.user_id"].to_s if env["allstak.user_id"]
+          if (session = env["rack.session"])
+            id = session["user_id"] || session[:user_id]
+            return id.to_s if id
+          end
+          nil
+        end
+
+        def build_user_context(env)
+          id = extract_user_id(env)
+          email = env["allstak.user_email"]
+          return nil if id.nil? && email.nil?
+          ip = env["REMOTE_ADDR"] || env["HTTP_X_FORWARDED_FOR"]
+          AllStak::Models::UserContext.new(id: id, email: email, ip: ip)
+        end
+      end
+    end
+  end
+end

data/lib/allstak/models/user_context.rb

@@ -0,0 +1,43 @@
+module AllStak
+  module Models
+    class UserContext
+      attr_accessor :id, :email, :ip
+
+      def initialize(id: nil, email: nil, ip: nil)
+        @id = id
+        @email = email
+        @ip = ip
+      end
+
+      def to_h
+        out = {}
+        out[:id]    = @id    unless @id.nil?
+        out[:email] = @email unless @email.nil?
+        out[:ip]    = @ip    unless @ip.nil?
+        out
+      end
+    end
+
+    class RequestContext
+      attr_accessor :method, :path, :host, :status_code, :user_agent
+
+      def initialize(method: nil, path: nil, host: nil, status_code: nil, user_agent: nil)
+        @method = method
+        @path = path
+        @host = host
+        @status_code = status_code
+        @user_agent = user_agent
+      end
+
+      def to_h
+        out = {}
+        out[:method]     = @method      unless @method.nil?
+        out[:path]       = @path        unless @path.nil?
+        out[:host]       = @host        unless @host.nil?
+        out[:statusCode] = @status_code unless @status_code.nil?
+        out[:userAgent]  = @user_agent  unless @user_agent.nil?
+        out
+      end
+    end
+  end
+end

data/lib/allstak/modules/cron.rb

@@ -0,0 +1,54 @@
+module AllStak
+  module Modules
+    # Cron / background-job monitoring. Backend auto-creates monitors on first ping.
+    class Cron
+      PATH = "/ingest/v1/heartbeat".freeze
+
+      def initialize(transport, logger, config = nil)
+        @transport = transport
+        @logger = logger
+        @config = config
+      end
+
+      # Wrap a job in a block; heartbeat sent on exit.
+      # On success → status "success". On raise → status "failed" with message,
+      # then the exception is re-raised.
+      #
+      # @example
+      #   AllStak.cron.job("daily-report") { generate_report }
+      def job(slug)
+        start = (Time.now.to_f * 1000).to_i
+        begin
+          result = yield
+          duration = (Time.now.to_f * 1000).to_i - start
+          ping(slug, "success", duration)
+          result
+        rescue => e
+          duration = (Time.now.to_f * 1000).to_i - start
+          ping(slug, "failed", duration, message: e.message)
+          raise
+        end
+      end
+
+      def ping(slug, status, duration_ms, message: nil)
+        return false if @transport.disabled?
+        begin
+          payload = { slug: slug, status: status, durationMs: duration_ms }
+          payload[:message] = message if message
+          if @config
+            payload[:environment] = @config.environment if @config.respond_to?(:environment) && @config.environment
+            payload[:release] = @config.release if @config.respond_to?(:release) && @config.release
+          end
+          code, _ = @transport.post(PATH, payload)
+          code == 202
+        rescue Transport::AllStakAuthError
+          @logger.debug("[AllStak] cron ping skipped — SDK disabled")
+          false
+        rescue => e
+          @logger.debug("[AllStak] cron ping failed silently: #{e.message}")
+          false
+        end
+      end
+    end
+  end
+end

data/lib/allstak/modules/database.rb

@@ -0,0 +1,89 @@
+require "digest"
+
+module AllStak
+  module Modules
+    # Database query telemetry, batched up to 100 per POST.
+    class Database
+      PATH = "/ingest/v1/db".freeze
+      BATCH_SIZE = 100
+
+      def initialize(transport, config, logger)
+        @transport = transport
+        @config = config
+        @logger = logger
+        @buffer = Transport::FlushBuffer.new(
+          name: "database",
+          max_size: config.buffer_size,
+          interval_ms: config.flush_interval_ms,
+          flush_proc: method(:flush_batch),
+          logger: logger
+        )
+      end
+
+      def record(sql:, duration_ms:, status: "success", error_message: nil,
+                 database_name: nil, database_type: nil, query_type: nil,
+                 rows_affected: -1, trace_id: nil, span_id: nil)
+        return if @transport.disabled?
+        normalized = self.class.normalize_query(sql)
+        @buffer.push({
+          normalizedQuery: normalized,
+          queryHash: self.class.hash_query(normalized),
+          queryType: query_type || self.class.detect_query_type(normalized),
+          durationMs: [duration_ms.to_i, 0].max,
+          timestampMillis: (Time.now.to_f * 1000).to_i,
+          status: status,
+          errorMessage: error_message && error_message.to_s[0, 500],
+          databaseName: database_name,
+          databaseType: database_type,
+          service: @config.service_name,
+          environment: @config.environment,
+          release: @config.respond_to?(:release) ? @config.release : nil,
+          traceId: trace_id,
+          spanId: span_id,
+          rowsAffected: rows_affected
+        }.compact)
+      end
+
+      def flush
+        @buffer.flush
+      end
+
+      def shutdown
+        @buffer.shutdown
+      end
+
+      def self.normalize_query(sql)
+        s = sql.to_s.dup
+        s.gsub!(/'[^']*'/, "?")
+        s.gsub!(/\b\d+(\.\d+)?\b/, "?")
+        s.gsub!(/\s+/, " ")
+        s.strip
+      end
+
+      def self.hash_query(normalized)
+        Digest::MD5.hexdigest(normalized)[0, 16]
+      end
+
+      def self.detect_query_type(sql)
+        first = sql.to_s.strip.split(/\s+/, 2).first.to_s.upcase
+        %w[SELECT INSERT UPDATE DELETE].include?(first) ? first : "OTHER"
+      end
+
+      private
+
+      def flush_batch(items)
+        items.each_slice(BATCH_SIZE) do |chunk|
+          begin
+            @transport.post(PATH, { queries: chunk })
+          rescue Transport::AllStakAuthError
+            return
+          rescue Transport::AllStakTransportError => e
+            @logger.debug("[AllStak] db batch transport error: #{e.message}")
+          rescue => e
+            @logger.debug("[AllStak] db batch unexpected error: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/allstak/modules/errors.rb

@@ -0,0 +1,111 @@
+require "json"
+
+module AllStak
+  module Modules
+    # Captures exceptions and sends them to AllStak.
+    class Errors
+      PATH = "/ingest/v1/errors".freeze
+      MAX_BREADCRUMBS = 50
+
+      def initialize(transport, config, logger)
+        @transport = transport
+        @config = config
+        @logger = logger
+        @current_user = nil
+        @breadcrumbs = []
+        @breadcrumb_mutex = Mutex.new
+      end
+
+      def set_user(id: nil, email: nil, ip: nil)
+        @current_user = Models::UserContext.new(id: id, email: email, ip: ip)
+      end
+
+      def clear_user
+        @current_user = nil
+      end
+
+      def add_breadcrumb(type:, message:, level: "info", data: nil)
+        @breadcrumb_mutex.synchronize do
+          @breadcrumbs.shift if @breadcrumbs.length >= MAX_BREADCRUMBS
+          @breadcrumbs << {
+            timestamp: Time.now.utc.iso8601(6),
+            type: type,
+            message: message,
+            level: level,
+            data: data
+          }.compact
+        end
+      end
+
+      def capture_exception(exc, level: "error", user: nil, request_context: nil, trace_id: nil, metadata: nil)
+        return nil if @transport.disabled?
+        begin
+          crumbs = @breadcrumb_mutex.synchronize do
+            next nil if @breadcrumbs.empty?
+            out = @breadcrumbs.dup
+            @breadcrumbs.clear
+            out
+          end
+
+          payload = {
+            exceptionClass: exc.class.name,
+            message: exc.message.to_s.empty? ? exc.class.name : exc.message.to_s,
+            stackTrace: extract_frames(exc),
+            level: level,
+            environment: @config.environment,
+            release: @config.release,
+            traceId: trace_id,
+            user: (user || @current_user)&.to_h,
+            requestContext: request_context&.to_h,
+            metadata: metadata,
+            breadcrumbs: crumbs
+          }.compact
+          payload.delete(:user)           if payload[:user]&.empty?
+          payload.delete(:requestContext) if payload[:requestContext]&.empty?
+
+          status, body = @transport.post(PATH, payload)
+          return nil unless status == 202
+          parsed = JSON.parse(body) rescue nil
+          parsed&.dig("data", "id")
+        rescue Transport::AllStakAuthError
+          nil
+        rescue => e
+          @logger.debug("[AllStak] capture_exception swallowed: #{e.class}: #{e.message}")
+          nil
+        end
+      end
+
+      def capture_error(exception_class, message, stack_trace: nil, level: "error", user: nil, request_context: nil, trace_id: nil, metadata: nil)
+        return nil if @transport.disabled?
+        begin
+          payload = {
+            exceptionClass: exception_class,
+            message: message,
+            stackTrace: stack_trace,
+            level: level,
+            environment: @config.environment,
+            release: @config.release,
+            traceId: trace_id,
+            user: (user || @current_user)&.to_h,
+            requestContext: request_context&.to_h,
+            metadata: metadata
+          }.compact
+          payload.delete(:user)           if payload[:user]&.empty?
+          payload.delete(:requestContext) if payload[:requestContext]&.empty?
+          status, _ = @transport.post(PATH, payload)
+          status == 202 ? exception_class : nil
+        rescue => e
+          @logger.debug("[AllStak] capture_error swallowed: #{e.class}: #{e.message}")
+          nil
+        end
+      end
+
+      private
+
+      def extract_frames(exc)
+        return [] unless exc.backtrace.is_a?(Array)
+        exc.backtrace.first(50)
+      end
+    end
+  end
+end

data/lib/allstak/modules/http_monitor.rb

@@ -0,0 +1,79 @@
+require "securerandom"
+
+module AllStak
+  module Modules
+    # Buffers + batches HTTP request telemetry (inbound and outbound).
+    # Max batch: 100.
+    class HttpMonitor
+      PATH = "/ingest/v1/http-requests".freeze
+      MAX_BATCH = 100
+
+      def initialize(transport, config, logger)
+        @transport = transport
+        @config = config
+        @logger = logger
+        @buffer = Transport::FlushBuffer.new(
+          name: "http",
+          max_size: config.buffer_size,
+          interval_ms: config.flush_interval_ms,
+          flush_proc: method(:flush_batch),
+          logger: logger
+        )
+      end
+
+      def record(direction:, method:, host:, path:, status_code:, duration_ms:,
+                 request_size: 0, response_size: 0, trace_id: nil, user_id: nil,
+                 error_fingerprint: nil, span_id: nil, parent_span_id: nil)
+        return if @transport.disabled?
+        item = {
+          direction: direction,
+          method: method.to_s.upcase,
+          host: host.to_s,
+          path: strip_query(path.to_s),
+          statusCode: status_code.to_i,
+          durationMs: [duration_ms.to_i, 0].max,
+          requestSize: request_size.to_i,
+          responseSize: response_size.to_i,
+          timestamp: Time.now.utc.iso8601(3),
+          traceId: trace_id || SecureRandom.hex(16),
+          userId: user_id,
+          errorFingerprint: error_fingerprint,
+          spanId: span_id,
+          parentSpanId: parent_span_id,
+          environment: @config.environment,
+          release: @config.release
+        }.compact
+        @buffer.push(item)
+      end
+
+      def flush
+        @buffer.flush
+      end
+
+      def shutdown
+        @buffer.shutdown
+      end
+
+      private
+
+      def strip_query(path)
+        idx = path.index("?")
+        idx ? path[0...idx] : path
+      end
+
+      def flush_batch(items)
+        items.each_slice(MAX_BATCH) do |chunk|
+          begin
+            @transport.post(PATH, { requests: chunk })
+          rescue Transport::AllStakAuthError
+            return
+          rescue Transport::AllStakTransportError => e
+            @logger.debug("[AllStak] http batch transport error: #{e.message}")
+          rescue => e
+            @logger.debug("[AllStak] http batch unexpected error: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/allstak/modules/logs.rb

@@ -0,0 +1,79 @@
+module AllStak
+  module Modules
+    # Buffered structured-log ingestion. Each log is sent as its own POST.
+    class Logs
+      PATH = "/ingest/v1/logs".freeze
+      VALID_LEVELS = %w[debug info warn error fatal].freeze
+
+      def initialize(transport, config, logger)
+        @transport = transport
+        @config = config
+        @logger = logger
+        @buffer = Transport::FlushBuffer.new(
+          name: "logs",
+          max_size: config.buffer_size,
+          interval_ms: config.flush_interval_ms,
+          flush_proc: method(:flush_batch),
+          logger: logger
+        )
+      end
+
+      def log(level, message, service: nil, trace_id: nil, span_id: nil,
+              request_id: nil, user_id: nil, error_id: nil, metadata: nil)
+        return if @transport.disabled?
+        level = normalize_level(level)
+
+        payload = {
+          level: level,
+          message: message.to_s,
+          service: service || @config.service_name,
+          environment: @config.environment,
+          release: @config.respond_to?(:release) ? @config.release : nil,
+          traceId: trace_id,
+          spanId: span_id,
+          requestId: request_id,
+          userId: user_id,
+          errorId: error_id,
+          metadata: metadata
+        }.compact
+        @buffer.push(payload)
+      end
+
+      def debug(msg, **kw); log("debug", msg, **kw); end
+      def info(msg, **kw);  log("info",  msg, **kw); end
+      def warn(msg, **kw);  log("warn",  msg, **kw); end
+      def error(msg, **kw); log("error", msg, **kw); end
+      def fatal(msg, **kw); log("fatal", msg, **kw); end
+
+      def flush
+        @buffer.flush
+      end
+
+      def shutdown
+        @buffer.shutdown
+      end
+
+      private
+
+      def normalize_level(level)
+        lv = level.to_s.downcase
+        lv = "warn" if lv == "warning"
+        VALID_LEVELS.include?(lv) ? lv : "info"
+      end
+
+      def flush_batch(items)
+        items.each do |item|
+          begin
+            @transport.post(PATH, item)
+          rescue Transport::AllStakAuthError
+            return
+          rescue Transport::AllStakTransportError => e
+            @logger.debug("[AllStak] log transport error (discarding): #{e.message}")
+          rescue => e
+            @logger.debug("[AllStak] unexpected log error: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end