diff --git a/lib/towerops_web/live/admin/monitoring_live.ex b/lib/towerops_web/live/admin/monitoring_live.ex
new file mode 100644
index 00000000..bfbede0b
--- /dev/null
+++ b/lib/towerops_web/live/admin/monitoring_live.ex
@@ -0,0 +1,113 @@
+defmodule ToweropsWeb.Admin.MonitoringLive do
+ @moduledoc """
+ Real-time job monitoring dashboard for Oban workers.
+
+ Displays:
+ - Active operations (currently executing jobs)
+ - Problems (stuck/failed jobs)
+ - Health metrics (throughput, errors, latency)
+ - Recent activity timeline
+ """
+ use ToweropsWeb, :live_view
+
+ alias Towerops.JobMonitoring
+ alias Towerops.JobMonitoring.Metrics
+
+ @topic "job:lifecycle"
+
+ @impl Phoenix.LiveView
+ def mount(_params, _session, socket) do
+ if connected?(socket) do
+ Phoenix.PubSub.subscribe(Towerops.PubSub, @topic)
+ end
+
+ socket =
+ socket
+ |> assign(:page_title, "Job Monitoring")
+ |> assign(:active_jobs, [])
+ |> assign(:executing_jobs, [])
+ |> assign(:stuck_jobs, [])
+ |> assign(:stuck_jobs_count, 0)
+ |> assign(:failed_jobs, [])
+ |> assign(:failed_jobs_count, 0)
+ |> assign(:recent_jobs, [])
+ |> assign(:recent_events, [])
+ |> assign(:metrics, %{})
+ |> assign(:health_metrics, %{})
+ |> load_monitoring_data()
+
+ {:ok, socket}
+ end
+
+ @impl Phoenix.LiveView
+ def handle_info(%{event: :started} = event, socket) do
+ # Job started - add to active jobs list
+ active_jobs = [event | socket.assigns.active_jobs]
+ {:noreply, assign(socket, :active_jobs, active_jobs)}
+ end
+
+ def handle_info(%{event: event} = job_event, socket) when event in [:completed, :failed] do
+ # Job finished - remove from active jobs, reload data
+ active_jobs = Enum.reject(socket.assigns.active_jobs, fn job -> job.job_id == job_event.job_id end)
+
+ socket =
+ socket
+ |> assign(:active_jobs, active_jobs)
+ |> load_monitoring_data()
+
+ {:noreply, socket}
+ end
+
+ def handle_info(_event, socket) do
+ {:noreply, socket}
+ end
+
+ @spec load_monitoring_data(Phoenix.LiveView.Socket.t()) :: Phoenix.LiveView.Socket.t()
+ defp load_monitoring_data(socket) do
+ executing_jobs = JobMonitoring.list_active_jobs()
+ stuck_jobs = JobMonitoring.list_stuck_jobs()
+ failed_jobs = JobMonitoring.list_failed_jobs()
+ recent_jobs = JobMonitoring.list_recent_completions(20)
+ metrics = Metrics.calculate_all()
+
+ socket
+ |> assign(:executing_jobs, executing_jobs)
+ |> assign(:stuck_jobs, stuck_jobs)
+ |> assign(:stuck_jobs_count, length(stuck_jobs))
+ |> assign(:failed_jobs, failed_jobs)
+ |> assign(:failed_jobs_count, length(failed_jobs))
+ |> assign(:recent_jobs, recent_jobs)
+ |> assign(:recent_events, recent_jobs)
+ |> assign(:metrics, metrics)
+ |> assign(:health_metrics, metrics)
+ end
+
+ defp worker_name("Towerops.Workers.DevicePollerWorker"), do: "Device Poll"
+ defp worker_name("Towerops.Workers.DiscoveryWorker"), do: "SNMP Discovery"
+ defp worker_name(worker), do: worker
+
+ defp duration_in_words(started_at) do
+ seconds = DateTime.diff(DateTime.utc_now(), started_at)
+ minutes = div(seconds, 60)
+
+ cond do
+ minutes < 1 -> "#{seconds}s"
+ minutes < 60 -> "#{minutes}m"
+ true -> "#{div(minutes, 60)}h #{rem(minutes, 60)}m"
+ end
+ end
+
+ defp event_border_color("completed"), do: "border-green-500"
+ defp event_border_color("cancelled"), do: "border-red-500"
+ defp event_border_color("discarded"), do: "border-gray-400"
+ defp event_border_color(_), do: "border-gray-300"
+
+ defp event_outcome(job) do
+ case job.state do
+ "completed" -> "Completed"
+ "cancelled" -> "Failed"
+ "discarded" -> "Discarded"
+ _ -> String.capitalize(job.state)
+ end
+ end
+end
diff --git a/lib/towerops_web/live/admin/monitoring_live.html.heex b/lib/towerops_web/live/admin/monitoring_live.html.heex
new file mode 100644
index 00000000..2ce87886
--- /dev/null
+++ b/lib/towerops_web/live/admin/monitoring_live.html.heex
@@ -0,0 +1,329 @@
+
+
+
+
+ Job Monitoring Dashboard
+
+
+ Real-time monitoring of polling and discovery jobs
+
+
+
+
+
+
+
Completed (1h)
+
+ {Map.get(@health_metrics, :completed_last_hour, 0)}
+
+
jobs completed
+
+
+
+
Failed (1h)
+
+ {Map.get(@health_metrics, :failed_last_hour, 0)}
+
+
failures
+
+
+
+
Avg Duration
+
+ <%= if Map.get(@health_metrics, :avg_execution_time_seconds) do %>
+ {Map.get(@health_metrics, :avg_execution_time_seconds) |> Float.round(1)}s
+ <% else %>
+ N/A
+ <% end %>
+
+
last hour
+
+
+
+
Active Jobs
+
+ {length(@active_jobs)}
+
+
executing now
+
+
+
+
+
+
+ Active Operations ({length(@executing_jobs)})
+
+
+ <%= if length(@executing_jobs) == 0 do %>
+
No jobs currently executing
+ <% else %>
+
+ <%= for job <- @executing_jobs do %>
+
+
+
+
+ <%= if job.device do %>
+ <%= job.device.name %>
+ <% else %>
+ Device #{get_in(job.args, ["device_id"])}
+ <% end %>
+
+
+ <%= worker_name(job.worker) %>
+
+
+ Started <%= ToweropsWeb.TimeHelpers.format_time_ago(job.attempted_at) %>
+
+
+
+ <.icon name="hero-arrow-path" class="w-4 h-4 animate-spin text-blue-600" />
+
+
+
+ <% end %>
+
+ <% end %>
+
+
+
+ <%= if length(@stuck_jobs) > 0 or length(@failed_jobs) > 0 do %>
+
+
+ ⚠️ Problems Detected
+
+
+ <%= if length(@stuck_jobs) > 0 do %>
+
+
+ Stuck Jobs ({length(@stuck_jobs)})
+
+
+ <%= for job <- @stuck_jobs do %>
+
+
+
+
+ <%= if job.device do %>
+ <%= job.device.name %>
+ <% else %>
+ Device #{get_in(job.args, ["device_id"])}
+ <% end %>
+
+
+ <%= worker_name(job.worker) %>
+
+
+ Running for <%= duration_in_words(job.attempted_at) %>
+
+
+
+
+ <% end %>
+
+
+ <% end %>
+
+ <%= if length(@failed_jobs) > 0 do %>
+
+
+ Failed Jobs ({length(@failed_jobs)})
+
+
+ <%= for job <- Enum.take(@failed_jobs, 5) do %>
+
+
+
+
+ <%= if job.device do %>
+ <%= job.device.name %>
+ <% else %>
+ Device #{get_in(job.args, ["device_id"])}
+ <% end %>
+
+
+ <%= worker_name(job.worker) %> - Attempt <%= job.attempt %>/<%= job.max_attempts %>
+
+ <%= if job.errors && length(job.errors) > 0 do %>
+
+ <%= hd(job.errors)["error"] || "Unknown error" %>
+
+ <% end %>
+
+
+
+ <% end %>
+
+
+ <% end %>
+
+ <% end %>
+
+
+
+
+ Health Metrics
+
+
+
+
+
+ Current Activity
+
+
+
+
Executing
+
+ {@metrics.executing_count}
+
+
+
+
Queued
+
+ {@metrics.queued_count}
+
+
+
+
Completed (1h)
+
+ {@metrics.completed_last_hour}
+
+
+
+
Failed (1h)
+
+ {@metrics.failed_last_hour}
+
+
+
+
+
+
+
+
+ Success Rates
+
+
+
+
+ Polling (1h)
+
+ <%= Float.round(@metrics.polling_success_rate_1h * 100, 1) %>%
+
+
+
+
+
+
+
+ Discovery (1h)
+
+ <%= Float.round(@metrics.discovery_success_rate_1h * 100, 1) %>%
+
+
+
+
+
+
+
+
+
+
+ Performance
+
+
+
+
- Avg Execution Time
+ -
+ <%= if @metrics.avg_execution_time_seconds do %>
+ <%= Float.round(@metrics.avg_execution_time_seconds, 1) %>s
+ <% else %>
+ N/A
+ <% end %>
+
+
+
+
- Jobs/Hour
+ -
+ {@metrics.completed_last_hour}
+
+
+
+
+
+
+
+
+ Queue Depths
+
+
+
+
- Pollers
+ -
+ {@metrics.queue_depths.pollers}
+
+
+
+
- Discovery
+ -
+ {@metrics.queue_depths.discovery}
+
+
+
+
+
+
+
+ Updates every 10 seconds
+
+
+
+
+
+
+
+ Recent Activity
+
+
+ <%= if length(@recent_events) == 0 do %>
+
No recent activity
+ <% else %>
+
+ <%= for job <- Enum.take(@recent_events, 50) do %>
+
+
+
+
+ <%= if job.device do %>
+ <%= job.device.name %>
+ <% else %>
+ Device #{get_in(job.args, ["device_id"])}
+ <% end %>
+
+
+ <%= worker_name(job.worker) %> · <%= event_outcome(job) %>
+
+
+
+ <%= ToweropsWeb.TimeHelpers.format_time_ago(job.completed_at || job.updated_at) %>
+
+
+
+ <% end %>
+
+ <% end %>
+
+
diff --git a/lib/towerops_web/router.ex b/lib/towerops_web/router.ex
index 893b6c35..47873496 100644
--- a/lib/towerops_web/router.ex
+++ b/lib/towerops_web/router.ex
@@ -231,6 +231,7 @@ defmodule ToweropsWeb.Router do
live "/users", UserLive.Index, :index
live "/organizations", OrgLive.Index, :index
live "/audit", AuditLive.Index, :index
+ live "/monitoring", MonitoringLive, :index
end
end
diff --git a/test/support/fixtures/jobs_fixtures.ex b/test/support/fixtures/jobs_fixtures.ex
new file mode 100644
index 00000000..d7d3e281
--- /dev/null
+++ b/test/support/fixtures/jobs_fixtures.ex
@@ -0,0 +1,35 @@
+defmodule Towerops.JobsFixtures do
+ @moduledoc """
+ This module defines test helpers for creating Oban jobs for testing.
+ """
+
+ alias Towerops.Repo
+
+ @doc """
+ Generate an Oban job with all required fields.
+ """
+ def oban_job_fixture(attrs \\ %{}) do
+ default_attrs = %{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ queue: "pollers",
+ args: %{"device_id" => 1},
+ state: "available",
+ attempt: 0,
+ max_attempts: 3,
+ inserted_at: DateTime.utc_now(),
+ scheduled_at: DateTime.utc_now()
+ }
+
+ merged_attrs =
+ Map.merge(
+ default_attrs,
+ attrs |> Map.new(fn {k, v} -> {to_atom_key(k), v} end)
+ )
+
+ job = struct!(Oban.Job, merged_attrs)
+ Repo.insert!(job)
+ end
+
+ defp to_atom_key(key) when is_atom(key), do: key
+ defp to_atom_key(key) when is_binary(key), do: String.to_existing_atom(key)
+end
diff --git a/test/towerops/job_monitoring/events_test.exs b/test/towerops/job_monitoring/events_test.exs
new file mode 100644
index 00000000..b8e82e78
--- /dev/null
+++ b/test/towerops/job_monitoring/events_test.exs
@@ -0,0 +1,28 @@
+defmodule Towerops.JobMonitoring.EventsTest do
+ use Towerops.DataCase, async: true
+
+ alias Towerops.JobMonitoring.Events
+
+ describe "broadcast_job_event/3" do
+ test "broadcasts job lifecycle event to PubSub" do
+ Phoenix.PubSub.subscribe(Towerops.PubSub, "job:lifecycle")
+
+ job = %Oban.Job{
+ id: 123,
+ worker: "Towerops.Workers.DevicePollerWorker",
+ args: %{"device_id" => 456}
+ }
+
+ Events.broadcast_job_event(job, :started, %{})
+
+ assert_receive %{
+ job_id: 123,
+ worker: "Towerops.Workers.DevicePollerWorker",
+ device_id: 456,
+ event: :started,
+ metadata: %{},
+ timestamp: %DateTime{}
+ }
+ end
+ end
+end
diff --git a/test/towerops/job_monitoring/metrics_test.exs b/test/towerops/job_monitoring/metrics_test.exs
new file mode 100644
index 00000000..a6859263
--- /dev/null
+++ b/test/towerops/job_monitoring/metrics_test.exs
@@ -0,0 +1,50 @@
+defmodule Towerops.JobMonitoring.MetricsTest do
+ use Towerops.DataCase, async: true
+
+ import Towerops.DevicesFixtures
+ import Towerops.JobsFixtures
+
+ alias Towerops.JobMonitoring.Metrics
+
+ describe "calculate_all/0" do
+ test "returns comprehensive metrics structure" do
+ # Create device without SNMP to avoid auto-scheduling polling job
+ device = device_fixture(%{snmp_enabled: false})
+
+ # Executing jobs
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ queue: "pollers"
+ })
+
+ # Queued jobs
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "scheduled",
+ args: %{"device_id" => device.id},
+ queue: "discovery"
+ })
+
+ # Completed jobs (last hour)
+ now = DateTime.utc_now()
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "completed",
+ args: %{"device_id" => device.id},
+ completed_at: DateTime.add(now, -1800, :second),
+ attempted_at: DateTime.add(now, -1810, :second),
+ queue: "pollers"
+ })
+
+ metrics = Metrics.calculate_all()
+
+ assert metrics.executing_count == 1
+ assert metrics.queued_count == 1
+ assert metrics.completed_last_hour == 1
+ assert is_float(metrics.polling_success_rate_1h)
+ assert is_map(metrics.queue_depths)
+ end
+ end
+end
diff --git a/test/towerops/job_monitoring_test.exs b/test/towerops/job_monitoring_test.exs
new file mode 100644
index 00000000..ea996cc9
--- /dev/null
+++ b/test/towerops/job_monitoring_test.exs
@@ -0,0 +1,263 @@
+defmodule Towerops.JobMonitoringTest do
+ use Towerops.DataCase, async: true
+
+ import Towerops.DevicesFixtures
+ import Towerops.JobsFixtures
+
+ alias Towerops.JobMonitoring
+
+ describe "list_active_jobs/0" do
+ test "returns jobs in executing state for polling and discovery workers" do
+ device = device_fixture()
+
+ # Create jobs with different attempted_at times
+ older_job = oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -60, :second) # 60 seconds ago
+ })
+
+ newer_job = oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.utc_now() # Now
+ })
+
+ # Create completed job (should not be returned)
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "completed",
+ args: %{"device_id" => device.id}
+ })
+
+ jobs = JobMonitoring.list_active_jobs()
+
+ assert length(jobs) == 2
+ assert Enum.all?(jobs, fn j -> j.state == "executing" end)
+
+ # Verify ascending order by attempted_at
+ assert hd(jobs).id == older_job.id
+ assert List.last(jobs).id == newer_job.id
+ end
+
+ test "excludes jobs from other workers" do
+ device = device_fixture()
+
+ # Create job from non-monitored worker
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.SomeOtherWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.utc_now()
+ })
+
+ # Create job from monitored worker
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.utc_now()
+ })
+
+ jobs = JobMonitoring.list_active_jobs()
+
+ # Should only return the DevicePollerWorker job
+ assert length(jobs) == 1
+ assert hd(jobs).worker == "Towerops.Workers.DevicePollerWorker"
+ end
+ end
+
+ describe "list_stuck_jobs/0" do
+ test "returns polling jobs executing longer than 2 minutes" do
+ device = device_fixture()
+
+ # Stuck polling job (3 minutes ago)
+ stuck_job = oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -180, :second)
+ })
+
+ # Recent polling job (30 seconds ago) - not stuck
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -30, :second)
+ })
+
+ stuck = JobMonitoring.list_stuck_jobs()
+
+ assert length(stuck) == 1
+ assert hd(stuck).id == stuck_job.id
+ end
+
+ test "returns discovery jobs executing longer than 5 minutes" do
+ device = device_fixture()
+
+ # Stuck discovery job (6 minutes ago)
+ stuck_job = oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -360, :second)
+ })
+
+ # Recent discovery job (3 minutes ago) - not stuck
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -180, :second)
+ })
+
+ stuck = JobMonitoring.list_stuck_jobs()
+
+ assert length(stuck) == 1
+ assert hd(stuck).id == stuck_job.id
+ end
+
+ test "returns stuck jobs from both worker types ordered by attempted_at" do
+ device = device_fixture()
+
+ # Stuck polling job (3 minutes ago)
+ stuck_poller = oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -180, :second)
+ })
+
+ # Stuck discovery job (6 minutes ago - older, should be first)
+ stuck_discovery = oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -360, :second)
+ })
+
+ # Recent jobs that should not be included
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -30, :second)
+ })
+
+ stuck = JobMonitoring.list_stuck_jobs()
+
+ assert length(stuck) == 2
+ # Verify oldest first (discovery job at -360s)
+ assert Enum.at(stuck, 0).id == stuck_discovery.id
+ assert Enum.at(stuck, 1).id == stuck_poller.id
+ end
+
+ test "excludes jobs just under the threshold boundary" do
+ device = device_fixture()
+
+ # Polling job at 119 seconds - should NOT be stuck (under 120s threshold)
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -119, :second)
+ })
+
+ # Discovery job at 299 seconds - should NOT be stuck (under 300s threshold)
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -299, :second)
+ })
+
+ assert JobMonitoring.list_stuck_jobs() == []
+ end
+
+ test "includes jobs just over the threshold" do
+ device = device_fixture()
+
+ # Polling job at 125 seconds - should be stuck (over 120s threshold)
+ stuck_poller = oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -125, :second)
+ })
+
+ # Discovery job at 305 seconds - should be stuck (over 300s threshold)
+ stuck_discovery = oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.add(DateTime.utc_now(), -305, :second)
+ })
+
+ stuck = JobMonitoring.list_stuck_jobs()
+
+ assert length(stuck) == 2
+ assert stuck |> Enum.map(& &1.id) |> Enum.sort() == [stuck_discovery.id, stuck_poller.id] |> Enum.sort()
+ end
+ end
+
+ describe "list_failed_jobs/0" do
+ test "returns retryable and cancelled jobs" do
+ device = device_fixture()
+
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "retryable",
+ args: %{"device_id" => device.id}
+ })
+
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DiscoveryWorker",
+ state: "cancelled",
+ args: %{"device_id" => device.id}
+ })
+
+ # Should not include completed
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "completed",
+ args: %{"device_id" => device.id}
+ })
+
+ failed = JobMonitoring.list_failed_jobs()
+
+ assert length(failed) == 2
+ assert Enum.all?(failed, fn j -> j.state in ["retryable", "cancelled"] end)
+ end
+ end
+
+ describe "list_recent_completions/1" do
+ test "returns completed, cancelled, and discarded jobs up to limit" do
+ device = device_fixture()
+
+ # Create 5 completed jobs
+ for _ <- 1..5 do
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "completed",
+ args: %{"device_id" => device.id},
+ completed_at: DateTime.utc_now()
+ })
+ end
+
+ # Should not include executing
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id}
+ })
+
+ recent = JobMonitoring.list_recent_completions(3)
+
+ assert length(recent) == 3
+ assert Enum.all?(recent, fn j -> j.state == "completed" end)
+ end
+ end
+end
diff --git a/test/towerops_web/live/admin/monitoring_live_test.exs b/test/towerops_web/live/admin/monitoring_live_test.exs
new file mode 100644
index 00000000..577209a7
--- /dev/null
+++ b/test/towerops_web/live/admin/monitoring_live_test.exs
@@ -0,0 +1,81 @@
+defmodule ToweropsWeb.Admin.MonitoringLiveTest do
+ use ToweropsWeb.ConnCase
+
+ import Phoenix.LiveViewTest
+ import Towerops.DevicesFixtures
+ import Towerops.JobsFixtures
+
+ describe "MonitoringLive" do
+ setup [:register_and_log_in_superuser]
+
+ test "renders monitoring dashboard", %{conn: conn} do
+ {:ok, _view, html} = live(conn, ~p"/admin/monitoring")
+
+ assert html =~ "Job Monitoring Dashboard"
+ assert html =~ "Active Operations"
+ assert html =~ "Problems"
+ assert html =~ "Health Metrics"
+ end
+
+ test "subscribes to job lifecycle events", %{conn: conn} do
+ {:ok, view, _html} = live(conn, ~p"/admin/monitoring")
+
+ # Verify PubSub subscription by checking it's alive
+ assert Process.alive?(view.pid)
+ end
+
+ test "displays active operations section", %{conn: conn} do
+ {:ok, _view, html} = live(conn, ~p"/admin/monitoring")
+
+ assert html =~ "Active Operations"
+ assert html =~ "No jobs currently executing"
+ end
+ end
+
+ describe "real-time updates" do
+ setup [:register_and_log_in_superuser]
+
+ test "displays executing jobs from database", %{conn: conn} do
+ device = device_fixture()
+
+ _job =
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id},
+ attempted_at: DateTime.utc_now()
+ })
+
+ {:ok, _view, html} = live(conn, ~p"/admin/monitoring")
+
+ # Should show the device name in executing jobs
+ assert html =~ device.name
+ assert html =~ "Active Operations (1)"
+ end
+ end
+
+ describe "metrics display" do
+ setup [:register_and_log_in_superuser]
+
+ test "shows current activity metrics", %{conn: conn} do
+ device = device_fixture()
+
+ oban_job_fixture(%{
+ worker: "Towerops.Workers.DevicePollerWorker",
+ state: "executing",
+ args: %{"device_id" => device.id}
+ })
+
+ {:ok, _view, html} = live(conn, ~p"/admin/monitoring")
+
+ assert html =~ "Executing"
+ assert html =~ "1"
+ end
+ end
+
+ defp register_and_log_in_superuser(%{conn: conn}) do
+ user = Towerops.AccountsFixtures.user_fixture()
+ user = Towerops.Repo.update!(Ecto.Changeset.change(user, is_superuser: true))
+ %{conn: log_in_user(conn, user), user: user}
+ end
+end