sentiero 1.0.0.alpha1

data/lib/sentiero/web/views/funnel_view.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class FunnelView < BaseView
+        def initialize(tags:, selected_steps:, steps:, was_truncated:, since:, until_str:)
+          super()
+          @tags = tags
+          @selected_steps = selected_steps
+          @steps = steps
+          @was_truncated = was_truncated
+          @since = since
+          @until_str = until_str
+        end
+
+        attr_reader :tags, :selected_steps, :steps, :was_truncated, :since, :until_str
+
+        def template = "analytics_funnel.html.erb"
+
+        def format_gap(ms) = (ms < 1000) ? "#{ms.round}ms" : format_duration(0, ms)
+
+        def step_one_sessions = @step_one_sessions ||= steps.first&.fetch(:sessions).to_i
+
+        def next_step(i) = steps[i + 1]
+
+        def dropped(i)
+          n = next_step(i)
+          n ? steps[i][:sessions] - n[:sessions] : 0
+        end
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/heatmap_view.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rack"
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class HeatmapView < BaseView
+        def initialize(urls:, selected_url:, was_truncated:, config_json:, since:, until_str:)
+          super()
+          @urls = urls
+          @selected_url = selected_url
+          @was_truncated = was_truncated
+          @config_json = config_json
+          @since = since
+          @until_str = until_str
+        end
+
+        attr_reader :urls, :selected_url, :was_truncated, :config_json, :since, :until_str
+
+        def template = "heatmap.html.erb"
+
+        # Query holds server-side strings only; escaped at the h.call sink.
+        def page_report_href
+          q = {}
+          q["url"] = selected_url if selected_url && !selected_url.to_s.empty?
+          q.merge!(range_pairs)
+          "#{base_path}/analytics/page" + (q.empty? ? "" : "?" + Rack::Utils.build_query(q))
+        end
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/import_view.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class ImportView < BaseView
+        def template = "import.html.erb"
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/page_report_view.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rack"
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class PageReportView < BaseView
+        def initialize(report:, urls:, selected_url:, was_truncated:, since:, until_str:)
+          super()
+          @report = report
+          @urls = urls
+          @selected_url = selected_url
+          @was_truncated = was_truncated
+          @since = since
+          @until_str = until_str
+        end
+
+        attr_reader :report, :urls, :selected_url, :was_truncated, :since, :until_str
+
+        def template = "analytics_page.html.erb"
+
+        def secs(ms) = ms ? "#{(ms / 1000.0).round(1)}s" : "&mdash;"
+
+        def pct(rate) = "#{(rate * 100).round(1)}%"
+
+        def heatmap_href
+          q = {}
+          q["url"] = selected_url if selected_url && !selected_url.to_s.empty?
+          q.merge!(range_pairs)
+          "#{base_path}/analytics/heatmap" + (q.empty? ? "" : "?" + Rack::Utils.build_query(q))
+        end
+
+        def time_on_page = report[:time_on_page]
+        def entry_exit = report[:entry_exit]
+        def scroll = report[:scroll]
+        def forms = report[:forms]
+        def frustration = report[:frustration]
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/problem_show_view.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class ProblemShowView < BaseView
+        def initialize(problem:, occurrences:, session_ids:, session_summaries:, facets:, trend:)
+          super()
+          @problem = problem
+          @occurrences = occurrences
+          @session_ids = session_ids
+          @session_summaries = session_summaries
+          @facets = facets
+          @trend = trend
+        end
+
+        attr_reader :problem, :occurrences, :session_ids, :session_summaries, :facets, :trend
+
+        def template = "problem_show.html.erb"
+
+        def replay_href(s)
+          sid = s[:session_id]
+          if s[:window_id]
+            "#{h(base_path)}/sessions/#{h(sid)}/windows/#{h(s[:window_id])}"
+          else
+            "#{h(base_path)}/sessions/#{h(sid)}"
+          end
+        end
+
+        def spark_max = trend[:series].map { |day| day[:count] }.max || 0
+
+        def facet_groups
+          [
+            ["Top Request Paths", facets[:paths]],
+            ["Environments", facets[:environments]],
+            ["Browsers", facets[:browsers]]
+          ]
+        end
+
+        def has_facets? = facets[:releases].any? || facet_groups.any? { |_title, rows| rows.any? }
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/scroll_view.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "analyzer_view"
+
+module Sentiero
+  module Web
+    module Views
+      class ScrollView < AnalyzerView
+        def template = "analytics_scroll.html.erb"
+
+        def sorted_pages = pages.sort_by { |url, page| [-page[:session_count], url] }
+
+        def svg_width = 320
+        def svg_height = 140
+        def bar_gap = 12
+        def axis_y = svg_height - 24
+        def chart_top = 12
+        def bar_width = (svg_width - bar_gap * 5) / 4
+        def max_count(dist) = [dist.values.max, 1].max
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/segments_view.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class SegmentsView < BaseView
+        def initialize(filters:, browser_options:, device_options:, sessions:, page:, per_page:, has_next:, was_truncated:, filter_query:)
+          super()
+          @filters = filters
+          @browser_options = browser_options
+          @device_options = device_options
+          @sessions = sessions
+          @page = page
+          @per_page = per_page
+          @has_next = has_next
+          @was_truncated = was_truncated
+          @filter_query = filter_query
+        end
+
+        attr_reader :filters, :browser_options, :device_options, :sessions, :page, :per_page, :has_next, :was_truncated, :filter_query
+
+        def template = "segments.html.erb"
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/session_show_view.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class SessionShowView < BaseView
+        # Maximum tab buttons shown inline in the window switcher before the rest
+        # collapse into the overflow menu.
+        MAX_VISIBLE_TABS = 5
+
+        def initialize(session:, session_id:, window_id:, shareable_replays:, server_activity:)
+          super()
+          @session = session
+          @session_id = session_id
+          @window_id = window_id
+          @shareable_replays = shareable_replays
+          @server_activity = server_activity
+        end
+
+        attr_reader :session, :session_id, :window_id, :shareable_replays, :server_activity
+
+        def template = "session_show.html.erb"
+
+        def meta = session[:metadata]
+        def total_events = session[:windows]&.sum { |w| w[:event_count] } || 0
+        def duration_str = format_duration(session[:first_event_at], session[:last_event_at])
+        def multi_window? = tabs[:all].size > 1
+        def custom_keys = meta.keys - ["url", "referrer", "userAgent", "viewport"]
+
+        # Splits the session's windows into the switcher's inline tab buttons and
+        # overflow menu, keeping the active window visible. Windows are sorted by
+        # last activity and numbered once into {window:, tab_num:} pairs so the
+        # template never re-derives a tab number. Returns {all:, visible:, overflow:}.
+        def tabs
+          @tabs ||= partition_windows(session[:windows] || [], window_id)
+        end
+
+        # Player-relative server-activity markers, lazily so base_path (set after
+        # construction by render_page) is available.
+        def server_markers
+          @server_markers ||= build_server_markers
+        end
+
+        private
+
+        def partition_windows(windows, active_window_id, max_visible: MAX_VISIBLE_TABS)
+          sorted = windows.sort_by { |w| w[:last_event_at] || 0 }
+          tabs = sorted.each_with_index.map { |w, i| {window: w, tab_num: i + 1} }
+          return {all: tabs, visible: tabs, overflow: []} if tabs.size <= max_visible
+
+          # Show the first max_visible - 1 tabs (one slot is kept for the
+          # "+N more" button), swapping the last visible slot for the active
+          # tab when it would otherwise be hidden.
+          visible_indices = (0...(max_visible - 1)).to_a
+          active_idx = tabs.index { |t| t[:window][:window_id] == active_window_id }
+          visible_indices[-1] = active_idx if active_idx && !visible_indices.include?(active_idx)
+          visible = visible_indices.sort.map { |i| tabs[i] }
+          {all: tabs, visible: visible, overflow: tabs - visible}
+        end
+
+        # The player anchors t=0 at the window's first event (epoch MILLISECONDS);
+        # server timestamps are float SECONDS, so they are *1000 before subtracting
+        # the anchor. Offsets clamp to >= 0 so pre-window items pin at the start.
+        def build_server_markers
+          return [] if server_activity.nil? || server_activity.empty?
+
+          window = (session[:windows] || []).find { |w| w[:window_id] == window_id }
+          anchor_ms = window && window[:first_event_at]
+          return [] unless anchor_ms
+
+          server_activity.map { |item|
+            offset_ms = ((item[:timestamp] * 1000) - anchor_ms).round
+            offset_ms = 0 if offset_ms < 0
+
+            if item[:kind] == "exception"
+              occ = item[:occurrence]
+              cls = occ["exception_class"].to_s
+              msg = occ["message"].to_s
+              label = msg.empty? ? cls : "#{cls}: #{msg}"
+              {
+                offset_ms: offset_ms,
+                kind: "exception",
+                label: label[0, 120],
+                level: "error",
+                href: "#{base_path}/issues/#{occ["fingerprint"]}"
+              }
+            else
+              event = item[:event]
+              href = event["id"] ? "#{base_path}/custom-events/#{event["id"]}" : nil
+              {
+                offset_ms: offset_ms,
+                kind: "event",
+                label: event["name"].to_s[0, 120],
+                level: event["level"].to_s,
+                href: href
+              }
+            end
+          }.sort_by { |m| m[:offset_ms] }
+        end
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/sessions_index_view.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base_view"
+
+module Sentiero
+  module Web
+    module Views
+      class SessionsIndexView < BaseView
+        def initialize(sessions:, page:, per_page:, has_next:, search:, sort_by:, since:, until_param:, has_errors:)
+          super()
+          @sessions = sessions
+          @page = page
+          @per_page = per_page
+          @has_next = has_next
+          @search = search
+          @sort_by = sort_by
+          @since = since
+          @until_param = until_param
+          @has_errors = has_errors
+        end
+
+        attr_reader :sessions, :page, :per_page, :has_next, :search, :sort_by, :since, :until_param, :has_errors
+
+        def template = "sessions_index.html.erb"
+      end
+    end
+  end
+end

data/lib/sentiero/web/views/vitals_view.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "analyzer_view"
+
+module Sentiero
+  module Web
+    module Views
+      class VitalsView < AnalyzerView
+        RATING_COLORS = {"good" => "#16a34a", "needs-improvement" => "#d97706", "poor" => "#dc2626"}.freeze
+
+        def template = "analytics_vitals.html.erb"
+
+        def sorted_pages = pages.sort_by { |url, page| [-page[:sample_count], url] }
+
+        def dominant_rating(ratings) = ratings.max_by { |rating, count| [count, rating] }&.first
+
+        def rating_class(rating)
+          case rating
+          when "good" then "badge-success"
+          when "needs-improvement" then "badge-warning"
+          when "poor" then "badge-danger"
+          else "badge-neutral"
+          end
+        end
+
+        def rating_colors = RATING_COLORS
+
+        def page_rating_mix(page)
+          rating_colors.keys.to_h do |rating|
+            [rating, page[:metrics].sum { |_metric, m| m[:ratings].fetch(rating, 0) }]
+          end
+        end
+
+        def slowest(page)
+          %w[LCP INP CLS].each do |metric|
+            worst = page[:metrics].dig(metric, :worst)
+            return worst if worst
+          end
+          page[:metrics].each_value { |m| return m[:worst] if m[:worst] }
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/sentiero/web/views.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "views/base_view"
+require_relative "views/funnel_view"
+require_relative "views/conversions_view"
+require_relative "views/engagement_view"
+require_relative "views/page_report_view"
+require_relative "views/analytics_index_view"
+require_relative "views/segments_view"
+require_relative "views/forms_view"
+require_relative "views/heatmap_view"
+require_relative "views/export_view"
+require_relative "views/import_view"
+require_relative "views/analyzer_view"
+require_relative "views/scroll_view"
+require_relative "views/vitals_view"
+require_relative "views/frustration_view"
+require_relative "views/sessions_index_view"
+require_relative "views/session_show_view"
+require_relative "views/event_show_view"
+require_relative "views/events_index_view"
+require_relative "views/errors_index_view"
+require_relative "views/client_error_show_view"
+require_relative "views/problem_show_view"

data/lib/sentiero/window_ref.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Sentiero
+  # Addresses a single recording window by its (session_id, window_id) pair.
+  WindowRef = Data.define(:session_id, :window_id)
+end

data/lib/sentiero.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "sentiero/version"
+require_relative "sentiero/redaction"
+require_relative "sentiero/configuration"
+require_relative "sentiero/ip_anonymizer"
+require_relative "sentiero/store"
+require_relative "sentiero/erasure"
+require_relative "sentiero/stores/memory"
+require_relative "sentiero/web/events_app"
+require_relative "sentiero/web/ingest_app"
+require_relative "sentiero/web/errors_app"
+require_relative "sentiero/web/track_app"
+require_relative "sentiero/fingerprint"
+require_relative "sentiero/web/assets_app"
+require_relative "sentiero/web/manifest"
+require_relative "sentiero/web/base_app"
+require_relative "sentiero/web/basic_auth"
+require_relative "sentiero/web/dashboard_app"
+require_relative "sentiero/web/analytics_app"
+require_relative "sentiero/web/monitoring_app"
+require_relative "sentiero/web/script_tag"
+require_relative "sentiero/analytics/analyzer"
+
+module Sentiero
+  class Error < StandardError; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    # Resets the core config plus the Rails and Reporter configs when those
+    # subsystems are loaded — one teardown for tests instead of three.
+    def reset_all_configuration!
+      reset_configuration!
+      Sentiero::Rails.reset_configuration! if defined?(Sentiero::Rails) && Sentiero::Rails.respond_to?(:reset_configuration!)
+      Sentiero::Reporter.reset! if defined?(Sentiero::Reporter) && Sentiero::Reporter.respond_to?(:reset!)
+      configuration
+    end
+
+    def store
+      configuration.store || raise(Error, "No store configured.")
+    end
+
+    def purge_expired!
+      period = configuration.retention_period
+      return unless period
+
+      store.purge_older_than(period)
+    end
+
+    def erase_sessions(ids)
+      Erasure.erase_sessions(store, ids)
+    end
+
+    def erase_where(since: nil, until_time: nil)
+      Erasure.erase_where(store, since: since, until_time: until_time)
+    end
+  end
+end