sentiero 1.0.0.alpha1

data/lib/sentiero/store/session_store.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Sentiero
+  class Store
+    # The session-replay store contract: recording windows of
+    # rrweb events and reading them back as sessions.
+    #
+    # Window-level methods take a Sentiero::WindowRef; session-level methods
+    # take a bare session_id.
+    module SessionStore
+      def save_events(ref, events)
+        raise NoMethodError, "#{self.class}#save_events not implemented"
+      end
+
+      def list_sessions(limit:, offset: 0, since: nil, until_time: nil, sort_by: nil, search: nil)
+        raise NoMethodError, "#{self.class}#list_sessions not implemented"
+      end
+
+      def get_session(session_id)
+        raise NoMethodError, "#{self.class}#get_session not implemented"
+      end
+
+      def get_events(ref, after: nil, limit: nil)
+        raise NoMethodError, "#{self.class}#get_events not implemented"
+      end
+
+      def delete_session(session_id)
+        raise NoMethodError, "#{self.class}#delete_session not implemented"
+      end
+
+      def delete_window(ref)
+        raise NoMethodError, "#{self.class}#delete_window not implemented"
+      end
+
+      # Optional; default is a no-op so custom stores keep working without it.
+      def save_metadata(session_id, metadata)
+        nil
+      end
+
+      # Yields [session_summary_hash, window_id, events_array] per window, newest
+      # sessions first, capped at `limit`. Built from list_sessions/get_session/
+      # get_events so every backend gets it free; stores may override.
+      def each_session_events(limit: nil, since: nil, until_time: nil)
+        return enum_for(:each_session_events, limit: limit, since: since, until_time: until_time) unless block_given?
+
+        cap = limit || limits.analytics_max_scan_sessions
+        sessions = list_sessions(limit: cap, since: since, until_time: until_time)
+
+        sessions.each do |summary|
+          session = get_session(summary[:session_id])
+          next unless session
+
+          windows = session[:windows] || []
+          windows.each do |window|
+            window_id = window[:window_id]
+            events = get_events(WindowRef.new(summary[:session_id], window_id))
+            yield summary, window_id, events
+          end
+        end
+      end
+
+      # Deletes every session whose updated_at is older than `seconds` ago,
+      # returning the count. Built from list_sessions + delete_session so every
+      # backend gets it free; stores may override with a direct query.
+      #
+      # list_sessions is newest-first, so stale sessions are the last ones
+      # reached: we page through the whole store by advancing an offset (not just
+      # re-reading the first batch) and delete only after the full scan, so
+      # deletions don't shift the pages we're still walking.
+      def purge_older_than(seconds)
+        cutoff = Time.now.to_f - seconds
+        batch_size = limits.analytics_max_scan_sessions
+        stale = []
+        offset = 0
+
+        loop do
+          summaries = list_sessions(limit: batch_size, offset: offset)
+          break if summaries.empty?
+
+          stale.concat(
+            summaries
+              .select { |summary| summary[:updated_at] < cutoff }
+              .map { |summary| summary[:session_id] }
+          )
+          break if summaries.size < batch_size
+
+          offset += batch_size
+        end
+
+        stale.each { |session_id| delete_session(session_id) }
+        stale.size
+      end
+
+      private
+
+      # The session-summary shape returned by list_sessions/each_session_events,
+      # shared by every backend so the seven near-identical hash literals stay
+      # in exact lockstep. metadata is included only when present and non-empty,
+      # matching how each backend already treats "no metadata" as "no key".
+      def summary_hash(session_id:, window_ids:, event_count:, created_at:, updated_at:,
+        first_event_at: nil, last_event_at: nil, metadata: nil)
+        entry = {session_id: session_id, window_ids: window_ids, event_count: event_count,
+                 created_at: created_at, updated_at: updated_at,
+                 first_event_at: first_event_at, last_event_at: last_event_at}
+        entry[:metadata] = metadata if metadata && !metadata.empty?
+        entry
+      end
+
+      # True when the search term (case-insensitive) appears in the session_id
+      # or any metadata value.
+      def session_matches_search?(summary, search)
+        search_down = search.downcase
+        summary[:session_id].downcase.include?(search_down) ||
+          summary[:metadata]&.values&.any? { |value| value.to_s.downcase.include?(search_down) } || false
+      end
+    end
+  end
+end

data/lib/sentiero/store.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "window_ref"
+require_relative "store/limits"
+require_relative "store/session_store"
+require_relative "store/error_store"
+
+module Sentiero
+  # Abstract store contract, split across two mixins: SessionStore
+  # (session-replay recording) and ErrorStore (error tracking). Concrete
+  # backends subclass Store and implement both halves.
+  class Store
+    VALID_ID = /\A[a-zA-Z0-9_-]{1,128}\z/
+    MAX_METADATA_KEYS = 50
+    MAX_METADATA_VALUE_SIZE = 1024
+    VALID_STATUS = %w[open resolved ignored].freeze
+    PROBLEM_TITLE_MAX = 200
+
+    include SessionStore
+    include ErrorStore
+
+    attr_writer :limits
+
+    # Caps for eviction/scans. Defaults to Limits::DEFAULTS (static, not the
+    # global config); pass limits: Limits.from_configuration to bind it, or
+    # inject any other Limits to decouple a store from global state.
+    def limits
+      @limits ||= Limits.new
+    end
+
+    private
+
+    def validate_id!(id)
+      raise ArgumentError, "Invalid ID: #{id.inspect}" unless VALID_ID.match?(id.to_s)
+    end
+
+    def validate_window_ref!(ref)
+      validate_id!(ref.session_id)
+      validate_id!(ref.window_id)
+    end
+
+    def validate_metadata!(metadata)
+      raise ArgumentError, "metadata must be a Hash" unless metadata.is_a?(Hash)
+      metadata.each do |key, value|
+        raise ArgumentError, "metadata key too long" if key.to_s.length > 128
+        raise ArgumentError, "metadata value too large" if value.to_s.length > MAX_METADATA_VALUE_SIZE
+      end
+      raise ArgumentError, "too many metadata keys" if metadata.size > MAX_METADATA_KEYS
+    end
+
+    def validate_status!(status)
+      raise ArgumentError, "Invalid status: #{status.inspect}" unless VALID_STATUS.include?(status)
+    end
+
+    def validate_occurrence!(occurrence)
+      raise ArgumentError, "occurrence must be a Hash" unless occurrence.is_a?(Hash)
+      %w[fingerprint project exception_class message timestamp].each do |key|
+        raise ArgumentError, "occurrence missing #{key}" if occurrence[key].nil?
+      end
+      validate_id!(occurrence["fingerprint"])
+      validate_id!(occurrence["project"])
+    end
+
+    def validate_server_event!(event)
+      raise ArgumentError, "server event must be a Hash" unless event.is_a?(Hash)
+      %w[project name timestamp].each do |key|
+        raise ArgumentError, "server event missing #{key}" if event[key].nil?
+      end
+      validate_id!(event["project"])
+    end
+  end
+end