railwatch 0.8.0 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 35e3f727f70f3f5c73c0cbec4dfd83a79dc58141fd4b341c653433e8ae5be5d2
-  data.tar.gz: ff3832906ce67466c738a1ea9ec2d8178006c60958f1b3491e4fc31bea84aa3d
+  metadata.gz: d3e41b1890c573cc71fe35d7a9ac134dc3964e4250126bd7c898132800ba47d9
+  data.tar.gz: 84f59bb0bc68c014618c564533b0f3a5266062b1fac93a252a5a41c3632f0136
 SHA512:
-  metadata.gz: 674d67083f4ed5b3ca7153a18c0f6eaca9588763dc2d5ebf3fc7f40ce11ed54ed2626ea399186aa4d1acac4e22616775258ee3d76a6f01f3830aad11e5e422ad
-  data.tar.gz: 37db21eca95d40e29de0f47bf79b89e479acbd812d0381b808b606afe004efca328ac847b0a4db5a1bb78766df41fc44b9cf0e0738aa389e1aeead466ef441ef
+  metadata.gz: 4472da6ecdbb054cd17cae2a31cf3d1f0a5a6237e4964af2c9da04fa2b754a95a7aa91c268dd43ef9a29791762b82c2edffb446557b0f2b6b5a3a47f6b504a8c
+  data.tar.gz: 276639c1d1f4c9632892a419f83443407a41af5e33c062a426e50bf9a3f5fa8daf039b267157c14079e2c826dbd5b025e0a2e955d43450d28b59be31637fb6b4

data/CHANGELOG.md

@@ -6,6 +6,25 @@
      filled in by the release commit, which is also the only commit that
      touches lib/railwatch/version.rb and Gemfile.lock. See CONTRIBUTING.md. -->
 
+## 0.8.2 (2026-09-23)
+
+- The Profiles page's profiled share counts only the executions inside
+  its window. A window starting or ending mid-hour counted the whole of
+  its first and last hours, because a rollup holds its whole hour; the
+  partial hours are now counted from the rows.
+
+## 0.8.1 (2026-09-23)
+
+- The Tenants page reads only through the tenant-led indexes. Sparklines
+  are drawn for the tenants already found, by name. The untagged share is
+  the window's requests less the tagged ones, and the tagged ones are
+  counted per tenant. Both used to read every request in the window: over
+  a week, 11 s on an app with no tenants and 24 s on one with them.
+- A partial covering index serves the People page: 4 s over 30 days,
+  now 18 ms, from under a megabyte.
+- The Profiles page takes the window's execution count from rollups
+  instead of counting every execution (1.2 s over a week).
+
 ## 0.8.0 (2026-09-23)
 
 - Percentiles merged across hours are about ten times faster. Each

data/app/controllers/railwatch/profiles_controller.rb

@@ -13,7 +13,7 @@ module Railwatch
       rows, count, avg_samples, profiled, executions = telemetry do
         scope = Telemetry::Profile.between(from, to)
         [ scope.recent.limit(SCAN_LIMIT).select(:id, :group_hash, :execution_preview, :duration, :samples, :occurred_at).to_a,
-          scope.count, scope.average(:samples), scope.distinct.count(:execution_id), Telemetry::Execution.between(from, to).count ]
+          scope.count, scope.average(:samples), scope.distinct.count(:execution_id), executions_in(from, to) ]
       end
       render inertia: { profiles: groups(rows),
                         summary: { profiles: count, executions: executions, profiled: profiled, avg_samples: avg_samples.to_f.round(0) } }
@@ -29,6 +29,21 @@ module Railwatch
 
     private
 
+    # How many executions the window holds, as the profiled share's
+    # denominator. Every kind is rolled up, so whole hours come from a few
+    # hundred rollup rows rather than counting every execution (1.2 s over a
+    # week of the platform's own). A rollup holds its whole hour, so the
+    # partial hours at either end of the window are counted from the rows.
+    def executions_in(from, to)
+      first = from.beginning_of_hour == from ? from : from.beginning_of_hour + 1.hour
+      last = to.beginning_of_hour
+      return Telemetry::Execution.between(from, to).count if first >= last
+
+      Telemetry::Execution.where(occurred_at: from...first).count +
+        Telemetry::Rollup.for_type(Telemetry::Execution::KINDS).where(bucket: first...last).sum(:count) +
+        Telemetry::Execution.where(occurred_at: last..to).count
+    end
+
     # Rows arrive newest-first, so the head of each group is the profile the
     # page links to.
     def groups(rows)

data/app/models/railwatch/telemetry/tenant.rb

@@ -18,6 +18,9 @@ module Railwatch
       # aggregate), so only the busiest tenants get one; the rest report 0.
       P95_TENANTS = 50
       SPARKLINE_BUCKETS = 12
+      # Tenant names are bound one variable each, and SQLite allows 32,766
+      # per statement; an app with more tenants than that is asked in slices.
+      TENANT_SLICE = 1_000
       SORTS = { "requests" => :requests, "errors" => :errors, "p95" => :p95, "users" => :users }.freeze
 
       ERRORS_SQL = Arel.sql("SUM(CASE WHEN status >= 500 THEN 1 ELSE 0 END)")
@@ -35,7 +38,7 @@ module Railwatch
         absorb_counts(rows, filtered(Telemetry::Exception.between(from, to), q), :exceptions)
         absorb_counts(rows, filtered(Telemetry::Log.between(from, to), q), :logs)
         absorb_last_seen(rows, from, to, q)
-        absorb_sparklines(rows, from, to, q)
+        absorb_sparklines(rows, from, to)
         absorb_p95s(rows.values.max_by(P95_TENANTS) { |r| r[:requests] }, from, to)
         sorted(rows.values, sort, dir)
       end
@@ -43,20 +46,31 @@ module Railwatch
       # Headline numbers for the index page, computed from the rows it shows
       # (so the top-tenant share is a share of the listed tenants' requests)
       # plus the share of requests in the window that carry no tenant at all.
+      #
+      # The untagged count is the window's requests less the tagged ones,
+      # and the tagged ones are counted per tenant in app_tenant's index.
+      # Counting either side with app_tenant IS [NOT] NULL read every request
+      # in the window instead: 1 s on an untagged app, 24 s on a tagged one.
       def self.overview(rows, from, to)
         requests = Telemetry::Execution.requests.between(from, to)
         total = requests.count
-        untagged = requests.where(app_tenant: nil).count
+        tagged_total = tagged_tenants(from, to).each_slice(TENANT_SLICE).sum { |slice| requests.where(app_tenant: slice).count }
         tagged = rows.sum { |r| r[:requests] }
         top = rows.max_by { |r| r[:requests] }
         {
           tenants: rows.size, top_tenant: top && top[:tenant],
           top_share: tagged.zero? ? 0.0 : (top[:requests] * 100.0 / tagged).round(1),
           with_errors: rows.count { |r| r[:errors].positive? },
-          untagged_share: total.zero? ? 0.0 : (untagged * 100.0 / total).round(1)
+          untagged_share: total.zero? ? 0.0 : ((total - tagged_total) * 100.0 / total).round(1)
         }
       end
 
+      # Every tenant that sent anything in the window, from the tenant-led
+      # index (a skip-scan over distinct values, not the window's rows).
+      def self.tagged_tenants(from, to)
+        Telemetry::Execution.between(from, to).where.not(app_tenant: nil).distinct.pluck(:app_tenant)
+      end
+
       # Window totals for one tenant. Durations in milliseconds, like the rest
       # of the tenant props.
       def self.summary(tenant, from, to)
@@ -129,9 +143,19 @@ module Railwatch
           .each { |tenant, at| rows[tenant][:last_seen_at] = at }
       end
 
-      def self.absorb_sparklines(rows, from, to, q)
+      # Only for the tenants already found, by name: grouped by tenant and a
+      # time expression SQLite would not seek the app_tenant index and read
+      # every request in the window instead -- 11 s over a week on an app
+      # with no tenants at all, to draw nothing.
+      def self.absorb_sparklines(rows, from, to)
+        tenants = rows.keys.compact
+        return if tenants.empty?
+
         width = bucket_width(from, to, SPARKLINE_BUCKETS)
-        counts = filtered(Telemetry::Execution.requests.between(from, to), q).group(:app_tenant, bucket_sql(from, width)).count
+        counts = tenants.each_slice(TENANT_SLICE).flat_map do |slice|
+          Telemetry::Execution.requests.between(from, to).where(app_tenant: slice)
+            .group(:app_tenant, bucket_sql(from, width)).count.to_a
+        end
         counts.each do |(tenant, index), count|
           rows[tenant][:sparkline][[ index.to_i, SPARKLINE_BUCKETS - 1 ].min] += count
         end

data/db/railwatch_telemetry_migrate/20260923000000_add_people_index.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# The People page groups the window's signed-in requests by user_ref.
+# Through (user_ref, occurred_at) SQLite found those rows but fetched each
+# one from the table for kind and status: 4 s over 30 days on the
+# platform's own tenant, where 18,000 of 2.8 million executions carry a
+# user. This index holds every column the query reads, and only for rows
+# that have a user, so it answers in 18 ms from under a megabyte. It took
+# 10 s to build on a copy of that 30 GB file.
+class AddPeopleIndex < ActiveRecord::Migration[8.1]
+  def change
+    add_index :executions, [ :user_ref, :kind, :occurred_at, :status ], name: "idx_executions_people",
+              where: "user_ref IS NOT NULL"
+  end
+end

data/lib/railwatch/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Railwatch
-  VERSION = "0.8.0"
+  VERSION = "0.8.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railwatch
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.2
 platform: ruby
 authors:
 - Cole Robertson
@@ -404,6 +404,7 @@ files:
 - db/railwatch_telemetry_migrate/20260917010000_add_batch_ledger_to_ingest_batches.rb
 - db/railwatch_telemetry_migrate/20260919000100_create_export_queue.rb
 - db/railwatch_telemetry_migrate/20260922000000_add_covering_indexes_for_dashboard_aggregates.rb
+- db/railwatch_telemetry_migrate/20260923000000_add_people_index.rb
 - docs/ai-and-mcp.md
 - docs/configuration.md
 - docs/embedded.md