agentmon 0.1.0

data/lib/agentmon/focus.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Agentmon
+  # Session focus: one agent session the whole dashboard (or a command) narrows to.
+  #
+  # The Engine holds the focus (`engine.focus = session_id`, `engine.focus = nil` clears it), and
+  # while it is set `engine.current` returns a FocusedReading: the same reading with every
+  # per-session value narrowed to that session. Panels and commands keep reading
+  # `engine.current[:process_rows]` and so on, and show only the focused session's processes,
+  # sessions, drivers and memory without knowing focus exists. Machine-wide values (`:memory`,
+  # anything not in FILTERS) pass through unchanged.
+  #
+  #   engine.focus = "claude-4242-1790711088"
+  #   engine.current[:process_rows]        # only that session's processes
+  #   engine.current.focus                 # => "claude-4242-1790711088" (nil when unfocused)
+  #   engine.current(focused: false)       # the whole machine, e.g. a picker listing every session
+  #   engine.focused_session               # its Session from the ledger, nil when unfocused or gone
+  #   engine.focus = nil                   # everything again
+  #
+  # The filters are per shape in model.rb, so a new per-session shape (a contract change) adds its
+  # filter here in the same PR. `reading.sample` is never filtered: code that reads raw probe
+  # values sees the whole machine.
+  module Focus
+    # metric name => ->(value, session_id, unfocused_reading) { narrowed value }. Values are never
+    # nil here (nil passes through).
+    FILTERS = {
+      process_rows: ->(rows, id, _) { rows.select { |r| r.session_id == id } },
+      process_rates: lambda do |rates, id, reading|
+        by_pid = reading[:sessions]&.by_pid || {}
+        rates.select { |pid, _| by_pid[pid] == id }
+      end,
+      sessions: lambda do |map, id, _|
+        SessionMap.new(sessions: map.sessions.select { |s| s.id == id }, by_pid: map.by_pid.select { |_, s| s == id })
+      end,
+      session_ledger: ->(sessions, id, _) { sessions.select { |s| s.id == id } },
+      pressure_drivers: ->(drivers, id, _) { drivers.select { |d| d.session_id == id } },
+      session_memory: ->(rows, id, _) { rows.select { |r| r.session_id == id } },
+      net_rates: lambda do |rates, id, reading|
+        by_pid = reading[:sessions]&.by_pid || {}
+        rates.select { |pid, _| by_pid[pid] == id }
+      end,
+      session_network: ->(rows, id, _) { rows.select { |r| r.session_id == id } },
+      connections: ->(rows, id, _) { rows.select { |r| r.session_id == id } }
+    }.freeze
+
+    module_function
+
+    # `reading` narrowed to `session_id`; the reading itself when nil.
+    def apply(reading, session_id) = session_id ? FocusedReading.new(reading, session_id) : reading
+
+    # Sessions a user's query names (CLI `--session`, a typed filter): an exact id or root pid
+    # first, else every session whose label contains it (case-insensitive). [] when none.
+    def find(sessions, query)
+      query = query.to_s
+      exact = sessions.select { |s| s.id == query || s.root_pid.to_s == query }
+      return exact unless exact.empty?
+
+      sessions.select { |s| s.label.downcase.include?(query.downcase) }
+    end
+  end
+
+  # A Reading narrowed to one session (see Focus). Every filtered value is computed once, when
+  # the Engine builds it under its lock, so feed threads only look values up.
+  class FocusedReading
+    attr_reader :focus, :unfocused
+
+    def initialize(reading, session_id)
+      @unfocused = reading
+      @focus = session_id
+      @values = Focus::FILTERS.each_with_object({}) do |(name, filter), values|
+        value = reading[name]
+        values[name] = value.nil? ? nil : filter.call(value, session_id, reading)
+      end
+    end
+
+    def [](name)
+      name = name.to_sym
+      @values.key?(name) ? @values[name] : @unfocused[name]
+    end
+
+    def sample = @unfocused.sample
+    def previous = @unfocused.previous
+    def errors = @unfocused.errors
+    def at = @unfocused.at
+    def interval = @unfocused.interval
+    def key?(name) = @unfocused.key?(name)
+  end
+end

data/lib/agentmon/metrics/memory.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+# reading[:memory]: the machine's memory as Activity Monitor breaks it down, as a MemoryView
+# (lib/agentmon/model.rb), derived from the memory probe's MemoryStat (sample[:memory]). Nil while
+# there is no MemoryStat (the probe hasn't merged, or failed before its first read).
+#
+#   used               app + wired + compressed (Activity Monitor's "Memory Used")
+#   compression_ratio  compressor_stored / compressed: 3.0 means 3 GiB of app memory squeezed into
+#                      1 GiB of RAM; 0.0 when nothing is compressed
+#   *_rate             swap-ins, swap-outs, compressions and decompressions in bytes/s: the counter
+#                      deltas over the monotonic interval since the previous sample. 0.0 on the first
+#                      sample (or after one without memory) and when a counter went backwards (it
+#                      can reset across sleep); never negative
+#   pressure           100 - kern.memorystatus_level, in percent (0 = no pressure)
+#   pressure_trend     the last 60 pressures (two minutes at 2 s), oldest first: metric state
+#
+# Example, 16 GiB Mac under some load:
+#
+#   MemoryView(total: 16G, used: 9G, app: 6G, wired: 2G, compressed: 1G, compression_ratio: 3.0,
+#              swapin_rate: 2097152.0, ..., pressure: 30.0, pressure_trend: [28.0, 29.0, 30.0])
+#
+# A field the probe couldn't read (nil) stays nil here: its sum, ratio or rate is unknown, not 0.
+module Agentmon
+  module Metrics
+    # Named apart from the MemoryView/MemoryStat models and the memory probe's module.
+    module MemoryBreakdown
+      TREND = 60
+      COUNTERS = { swapin_rate: :swapins, swapout_rate: :swapouts,
+                   compression_rate: :compressions, decompression_rate: :decompressions }.freeze
+
+      module_function
+
+      # `now` and `before` are MemoryStats (`before` nil on the first sample); `trend` is the
+      # metric's state Array, appended to in place.
+      def call(now, before, interval, trend)
+        return nil unless now
+
+        pressure = now.memorystatus_level && (100.0 - now.memorystatus_level)
+        if pressure
+          trend << pressure
+          trend.shift while trend.size > TREND
+        end
+
+        MemoryView.new(
+          total: now.total, used: sum(now.app, now.wired, now.compressed),
+          app: now.app, wired: now.wired, compressed: now.compressed, cached: now.cached, free: now.free,
+          swap_used: now.swap_used, swap_total: now.swap_total,
+          compression_ratio: ratio(now.compressor_stored, now.compressed),
+          **COUNTERS.to_h { |rate, counter| [rate, rate(now.public_send(counter), before&.public_send(counter), interval)] },
+          pressure:, pressure_trend: trend.dup.freeze
+        )
+      end
+
+      def sum(*parts) = parts.include?(nil) ? nil : parts.sum
+
+      def ratio(stored, compressed)
+        return nil if stored.nil? || compressed.nil?
+
+        compressed.positive? ? stored.to_f / compressed : 0.0
+      end
+
+      # Bytes/s between two readings of a cumulative counter.
+      def rate(now, was, interval)
+        return nil if now.nil?
+        return 0.0 if was.nil? || interval.nil? || !interval.positive?
+
+        [now - was, 0].max / interval.to_f
+      end
+    end
+  end
+
+  metric(:memory) do |reading, state|
+    Metrics::MemoryBreakdown.call(reading.sample[:memory], reading.previous&.[](:memory), reading.interval,
+                                  state[:trend] ||= [])
+  end
+end

data/lib/agentmon/metrics/network.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+# Per-process and per-session network, from the nettop snapshots in sample[:network]
+# (probes/network.rb). Every metric here is nil while sample[:network] is nil (no snapshot yet,
+# nettop stalled or missing, off macOS): unknown, never 0.
+#
+# reading[:net_rates]: { pid => NetRates or nil }, bytes/s between the previous nettop snapshot and
+#   this one, over the snapshots' own at_mono (nettop runs at 1 s, the engine at 2 s). A pid's rate
+#   needs the same process as before: the same start_ticks in sample[:processes] and the same
+#   nettop name; a reused pid, a first sighting, or a counter that went down is nil. A process in
+#   the sample with no nettop line has no sockets: 0.0. When the sample carries the very snapshot
+#   the previous one did (nettop hasn't printed since), the previous rates are kept.
+#
+# reading[:session_network]: one SessionNetwork per session in reading[:sessions], each pid counted
+#   once (SessionMap#by_pid). Rates sum the members' known rates (members without sockets add
+#   0.0; nil when none is known). bytes_in/bytes_out add each member's positive counter growth while
+#   agentmon watched it (a first sighting adds 0, so these are lower bounds). Trends keep the last
+#   TREND known rates. connections counts member flows with a concrete remote; remote_hosts counts
+#   distinct remote hosts, loopback and link-local left out.
+#
+# Anomaly rule (flags; [] is normal), checked each time a new snapshot arrives:
+#   :out_spike   out_rate >= SPIKE_FACTOR (8) x the median of the session's previous BASELINE (30)
+#                known out_rate values, and >= SPIKE_FLOOR (1 MiB/s), with at least BASELINE_MIN (5)
+#                previous values
+#   :in_spike    the same for in_rate
+#   :many_hosts  remote_hosts >= MANY_HOSTS (20)
+#
+# reading[:connections]: one ConnectionRow per flow of a process in an agent session with a
+#   concrete remote (no `*` wildcard, not Listen), in nettop's order, with per-flow rates matched on
+#   (process identity, protocol, local, remote) between snapshots (nil the first time).
+module Agentmon
+  module Metrics
+    module Network
+      TREND = 120
+      SPIKE_FACTOR = 8.0
+      SPIKE_FLOOR = 1024.0 * 1024 # bytes/s
+      BASELINE = 30
+      BASELINE_MIN = 5
+      MANY_HOSTS = 20
+      NO_SOCKETS = NetRates.new(in_rate: 0.0, out_rate: 0.0)
+
+      module_function
+
+      # --- reading[:net_rates] ---
+
+      def rates(snap, processes, state)
+        return nil unless snap
+
+        ids = identities(processes)
+        prev = state[:snap]
+        if prev && prev.at_mono == snap.at_mono && state[:rates]
+          rates = state[:rates].dup
+        else
+          rates = between(snap, prev, ids, state[:ids] || {})
+          state.merge!(snap:, ids:, rates:)
+          rates = rates.dup
+        end
+        ids.each_key { |pid| rates[pid] = NO_SOCKETS unless rates.key?(pid) || snap.processes.key?(pid) }
+        rates.freeze
+      end
+
+      def between(snap, prev, ids, prev_ids)
+        seconds = prev && (snap.at_mono - prev.at_mono)
+        snap.processes.to_h do |pid, now|
+          was = prev&.processes&.[](pid)
+          same = was && seconds&.positive? && was.name == now.name && ids[pid] == prev_ids[pid]
+          next [pid, nil] unless same
+
+          in_rate = rate(now.bytes_in, was.bytes_in, seconds)
+          out_rate = rate(now.bytes_out, was.bytes_out, seconds)
+          [pid, in_rate.nil? && out_rate.nil? ? nil : NetRates.new(in_rate:, out_rate:)]
+        end
+      end
+
+      # --- reading[:session_network] ---
+
+      def sessions(snap, map, rates, processes, state)
+        return nil unless snap && map
+
+        rates ||= {}
+        ids = identities(processes)
+        fresh = state[:at] != snap.at_mono
+        state[:at] = snap.at_mono
+        members = map.by_pid.each_with_object(Hash.new { |h, k| h[k] = [] }) { |(pid, id), m| m[id] << pid }
+        seen = state[:seen] || {}
+        next_seen = seen.select { |(pid, ticks, _), _| ids.key?(pid) && ids[pid] == ticks }
+        totals = state[:totals] ||= {}
+        trends = state[:trends] ||= {}
+        spikes = state[:spikes] ||= {}
+
+        rows = map.sessions.map do |info|
+          pids = members[info.id]
+          procs = pids.filter_map { |pid| snap.processes[pid] }
+          total = totals[info.id] ||= [0, 0]
+          count_bytes(procs, ids, seen, next_seen, total) if fresh
+          in_rate = sum(pids, :in_rate, rates, snap)
+          out_rate = sum(pids, :out_rate, rates, snap)
+          trend = trends[info.id] ||= { in: [], out: [] }
+          if fresh
+            spikes[info.id] = [(:out_spike if spike?(out_rate, trend[:out])),
+                               (:in_spike if spike?(in_rate, trend[:in]))].compact
+            push(trend[:in], in_rate)
+            push(trend[:out], out_rate)
+          end
+          flows = procs.flat_map(&:flows).select(&:remote_host)
+          hosts = flows.map(&:remote_host).reject { |h| local_host?(h) }.uniq.size
+          flags = [*spikes[info.id], (:many_hosts if hosts >= MANY_HOSTS)].compact
+          SessionNetwork.new(session_id: info.id, label: info.label, in_rate:, out_rate:,
+                             bytes_in: total[0], bytes_out: total[1], in_trend: trend[:in].dup.freeze,
+                             out_trend: trend[:out].dup.freeze, connections: flows.size, remote_hosts: hosts,
+                             flags: flags.freeze)
+        end
+
+        state[:seen] = next_seen if fresh
+        alive = map.sessions.to_h { |s| [s.id, true] }
+        [totals, trends, spikes].each { |h| h.select! { |id, _| alive[id] } }
+        rows
+      end
+
+      # Adds each member's counter growth since it was last seen (first sighting: 0) to `total`.
+      def count_bytes(procs, ids, seen, next_seen, total)
+        procs.each do |np|
+          key = [np.pid, ids[np.pid], np.name]
+          was = seen[key]
+          if was
+            total[0] += growth(np.bytes_in, was[0])
+            total[1] += growth(np.bytes_out, was[1])
+          end
+          next_seen[key] = [np.bytes_in || was&.[](0), np.bytes_out || was&.[](1)]
+        end
+      end
+
+      # Sum of the members' known rates; a member with no nettop line has no sockets (0.0).
+      def sum(pids, field, rates, snap)
+        known = pids.filter_map do |pid|
+          if rates.key?(pid) then rates[pid]&.public_send(field)
+          elsif !snap.processes.key?(pid) then 0.0
+          end
+        end
+        known.empty? ? nil : known.sum.to_f
+      end
+
+      def spike?(value, history)
+        return false if value.nil?
+
+        base = history.last(BASELINE)
+        base.size >= BASELINE_MIN && value >= SPIKE_FLOOR && value >= SPIKE_FACTOR * median(base)
+      end
+
+      def median(values)
+        sorted = values.sort
+        mid = sorted.size / 2
+        sorted.size.odd? ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2.0
+      end
+
+      # --- reading[:connections] ---
+
+      def connections(snap, map, processes, state)
+        return nil unless snap && map
+
+        ids = identities(processes)
+        labels = map.sessions.to_h { |s| [s.id, s.label] }
+        prev = state[:snap]
+        same = prev && prev.at_mono == snap.at_mono
+        seconds = prev && !same ? snap.at_mono - prev.at_mono : nil
+        prev_bytes = state[:bytes] || {}
+        prev_rates = state[:rates] || {}
+        bytes = {}
+        new_rates = {}
+
+        rows = snap.processes.flat_map do |pid, np|
+          session_id = map.by_pid[pid] or next []
+          np.flows.filter_map do |f|
+            next unless f.remote_host && f.state != "Listen"
+
+            key = [pid, ids[pid], np.name, f.protocol, f.local, f.remote]
+            bytes[key] = [f.bytes_in, f.bytes_out]
+            in_rate, out_rate = new_rates[key] =
+              if same
+                prev_rates[key] || [nil, nil]
+              elsif (was = prev_bytes[key]) && seconds&.positive?
+                [rate(f.bytes_in, was[0], seconds), rate(f.bytes_out, was[1], seconds)]
+              else
+                [nil, nil]
+              end
+            ConnectionRow.new(pid:, name: np.name, session_id:, session: labels[session_id], protocol: f.protocol,
+                              local: f.local, remote: f.remote, remote_host: f.remote_host,
+                              remote_port: f.remote_port, interface: f.interface, state: f.state,
+                              bytes_in: f.bytes_in, bytes_out: f.bytes_out, in_rate:, out_rate:)
+          end
+        end
+
+        state.merge!(snap:, bytes:, rates: new_rates) unless same
+        rows
+      end
+
+      # --- shared ---
+
+      # pid => start_ticks (nil for unreadable processes: then the nettop name has to match alone).
+      def identities(processes) = (processes || []).to_h { |p| [p.pid, p.start_ticks] }
+
+      # Bytes/s between two cumulative counts; nil when either is unknown or it went down.
+      def rate(now, was, seconds)
+        return nil if now.nil? || was.nil? || now < was
+
+        (now - was) / seconds.to_f
+      end
+
+      def growth(now, was) = now && was && now > was ? now - was : 0
+
+      def push(trend, value)
+        return if value.nil?
+
+        trend << value
+        trend.shift while trend.size > TREND
+      end
+
+      # Loopback (127/8, ::1, localhost) or link-local (169.254/16, fe80::/10) hosts.
+      def local_host?(host)
+        address = host.sub(/%.*\z/, "")
+        return true if address == "localhost"
+
+        ip = IPAddr.new(address)
+        ip.loopback? || ip.link_local?
+      rescue IPAddr::Error
+        false
+      end
+    end
+  end
+
+  metric(:net_rates) do |reading, state|
+    Metrics::Network.rates(reading.sample[:network], reading.sample[:processes], state)
+  end
+
+  metric(:session_network) do |reading, state|
+    Metrics::Network.sessions(reading.sample[:network], reading[:sessions], reading[:net_rates],
+                              reading.sample[:processes], state)
+  end
+
+  metric(:connections) do |reading, state|
+    Metrics::Network.connections(reading.sample[:network], reading[:sessions], reading.sample[:processes], state)
+  end
+end

data/lib/agentmon/metrics/pressure_drivers.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# reading[:pressure_drivers]: the alive agent sessions ranked by how much memory they hold, as
+# PressureDriver records (lib/agentmon/model.rb), largest footprint first. For example:
+#
+#   claude 4242 · repo   2.1G   26.3%   +1.5M/s
+#   Claude 59334         900M   11.0%   -12K/s
+#
+# - footprint: the session's physical footprint now (bytes; readable members only).
+# - share: footprint as a percent of used memory (reading[:memory].used); nil while memory is
+#   unknown (no memory metric, or it failed this sample).
+# - growth_rate: footprint change in bytes per second over the last WINDOW seconds of samples
+#   (oldest kept sample to this one, on the monotonic clock); 0.0 until a session has two samples.
+#   Negative when it shrinks.
+#
+# Sessions with zero footprint (all members unreadable, or ended) are left out. Stateful: a short
+# footprint history per session id, dropped when the session is no longer alive.
+module Agentmon
+  module Metrics
+    class Drivers
+      WINDOW = 60.0
+
+      def initialize(state) = @state = state
+
+      def call(reading)
+        history = (@state[:history] ||= {}) # session id => [[mono, footprint], ...], oldest first
+        alive = (reading[:session_ledger] || []).select(&:alive?)
+        history.select! { |id, _| alive.any? { |s| s.id == id } }
+        used = reading[:memory]&.used
+        mono = reading.sample.mono
+
+        alive.filter_map do |session|
+          footprint = session.footprint || 0
+          growth = growth(history[session.id] ||= [], mono, footprint)
+          next unless footprint.positive?
+
+          PressureDriver.new(session_id: session.id, label: session.label, footprint:,
+                             share: used&.positive? ? footprint * 100.0 / used : nil, growth_rate: growth)
+        end.sort_by { |d| [-d.footprint, d.session_id] }
+      end
+
+      private
+
+      # Adds this sample to a session's points, forgets those older than WINDOW and returns the
+      # rate from the oldest left to this one.
+      def growth(points, mono, footprint)
+        points.pop if points.last && points.last[0] >= mono # the same sample seen again
+        points << [mono, footprint]
+        points.shift while mono - points.first[0] > WINDOW
+        since, was = points.first
+        mono > since ? (footprint - was) / (mono - since) : 0.0
+      end
+    end
+  end
+
+  metric(:pressure_drivers) { |reading, state| Metrics::Drivers.new(state).call(reading) }
+end

data/lib/agentmon/metrics/process_rates.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+# reading[:process_rates]: { pid => ProcessRates } between the previous sample and this one.
+#
+# CPU % is the change in CPU seconds over the monotonic interval, x100 (percent of one core, so a
+# process using four cores shows 400%). Disk rates are byte deltas over the interval. A pid only
+# matches the previous sample when its start time matches too, so a reused pid never produces a
+# rate from someone else's counters. Unreadable and newly seen processes fall back to ps's %cpu
+# and nil disk rates.
+#
+# Paging and scheduling rates the same way: pageins, faults, copy-on-write faults and context
+# switches per second, and `run_wait`, the percent of one core the process spent runnable but
+# waiting for a CPU (runnable time grows while a thread is on a CPU too, so CPU time is taken off).
+module Agentmon
+  module Metrics
+    # Named apart from the ProcessRates model so `ProcessRates.new` below means the model.
+    module Rates
+      module_function
+
+      def call(processes, previous, interval)
+        before = (previous || []).select(&:readable).to_h { |p| [p.identity, p] }
+        (processes || []).to_h do |p|
+          q = p.readable && interval&.positive? && before[p.identity]
+          [p.pid, q ? delta(p, q, interval) : ProcessRates.new(cpu: p.ps_cpu, read_rate: nil, write_rate: nil)]
+        end
+      end
+
+      def delta(now, was, seconds)
+        cpu = [now.cpu_time - was.cpu_time, 0].max
+        ProcessRates.new(
+          cpu: cpu / seconds * 100,
+          read_rate: [now.disk_read - was.disk_read, 0].max / seconds,
+          write_rate: [now.disk_written - was.disk_written, 0].max / seconds,
+          pagein_rate: per_second(now.pageins, was.pageins, seconds),
+          fault_rate: per_second(now.faults, was.faults, seconds, wrap: true),
+          cow_fault_rate: per_second(now.cow_faults, was.cow_faults, seconds, wrap: true),
+          context_switch_rate: per_second(now.context_switches, was.context_switches, seconds, wrap: true),
+          run_wait: run_wait(now, was, cpu, seconds)
+        )
+      end
+
+      # Events per second between two counts; nil when either is unknown. The task counters are
+      # 32 bits in the kernel, so with `wrap:` a count that went down wrapped at 2**32.
+      def per_second(now, was, seconds, wrap: false)
+        return nil if now.nil? || was.nil?
+
+        diff = now - was
+        diff %= 2**32 if wrap
+        [diff, 0].max / seconds.to_f
+      end
+
+      # Runnable time counts time on a CPU too, so waiting for one is runnable growth minus CPU
+      # growth, as percent of one core.
+      def run_wait(now, was, cpu, seconds)
+        return nil if now.runnable_time.nil? || was.runnable_time.nil?
+
+        [now.runnable_time - was.runnable_time - cpu, 0].max / seconds * 100
+      end
+    end
+  end
+
+  metric(:process_rates) do |reading|
+    Metrics::Rates.call(reading.sample[:processes], reading.previous&.[](:processes), reading.interval)
+  end
+end

data/lib/agentmon/metrics/process_rows.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# reading[:process_rows]: one ProcessRow per process, joining the probe's counters with rates,
+# working directories and session labels. What the dashboard's process table and the CLI print.
+module Agentmon
+  module Metrics
+    module ProcessRows
+      module_function
+
+      def call(processes, rates, cwds, sessions, net_rates = nil)
+        cwds ||= {}
+        rates ||= {} # nil when a metric failed this sample: show what the probe has
+        net_rates ||= {} # nil while there is no nettop snapshot: network rates unknown
+        sessions ||= SessionMap.new(sessions: [], by_pid: {})
+        labels = sessions.sessions.to_h { |s| [s.id, s.label] }
+        (processes || []).map do |p|
+          rate = rates[p.pid]
+          net = net_rates[p.pid]
+          session_id = sessions.by_pid[p.pid]
+          ProcessRow.new(
+            pid: p.pid, ppid: p.ppid, name: p.name, path: p.path, cwd: cwds[p.pid],
+            session: session_id && labels[session_id], session_id:,
+            cpu: rate&.cpu, footprint: p.footprint, resident: p.resident, peak_footprint: p.peak_footprint,
+            read_rate: rate&.read_rate, write_rate: rate&.write_rate,
+            cpu_time: p.cpu_time, disk_written: p.disk_written, started_at: p.started_at, readable: p.readable,
+            disk_read: p.disk_read, wired: p.wired, pageins: p.pageins, faults: p.faults, cow_faults: p.cow_faults,
+            context_switches: p.context_switches, runnable_time: p.runnable_time, threads: p.threads,
+            running_threads: p.running_threads, pagein_rate: rate&.pagein_rate, fault_rate: rate&.fault_rate,
+            cow_fault_rate: rate&.cow_fault_rate, context_switch_rate: rate&.context_switch_rate, run_wait: rate&.run_wait,
+            net_in_rate: net&.in_rate, net_out_rate: net&.out_rate
+          )
+        end
+      end
+    end
+  end
+
+  metric(:process_rows) do |reading|
+    Metrics::ProcessRows.call(reading.sample[:processes], reading[:process_rates], reading.sample[:cwd], reading[:sessions],
+                              reading[:net_rates])
+  end
+end