mirror of https://github.com/blakeblackshear/frigate.git synced 2026-10-24 07:24:42 +03:00

Files

T

Josh HawkinsandGitHub f385065981 Miscellaneous fixes (#24753 )

* materialize event counts in metrics endpoint

The metrics endpoint stored a lazy peewee query on the shared Prometheus collector, and collect() ran it later. Overlapping scrapes run in separate threadpool threads, so two requests could execute and step the same query's sqlite cursor at once. The rows are now read with list() before they reach the collector.

* fix fps overflow restarting ffmpeg after 3 seconds instead of 3 retry intervals

This is a regression from 0.18. The watchdog has restarted ffmpeg after 3 consecutive fps overflow checks since #13651, which was 3 retry intervals (30s by default) when the loop ran every retry_interval. #21297 moved the loop to 1s ticks without converting the count, so the window shrank to 3s. camera_fps is a 10s average, so one burst of buffered frames after a stream hiccup could keep it over the limit long enough to restart a healthy camera, and the next reconnect burst could repeat it. The threshold is now 3 * retry_interval ticks. When the count filled while restarts were still rate limited, the watchdog logged "Exiting ffmpeg...", marked the camera offline and reset the count without restarting. The check now waits for can_restart, so the log, status and restart always happen together.

* keep recording cleanup running after a failed pass

An exception anywhere in a cleanup pass, such as an OSError from a read-only or unmounted storage path, ended the recording cleanup thread with nothing logged. Retention stopped until restart, and recordings, previews and database rows kept growing. Each pass now logs the exception and the loop continues.

* expose frigate_camera_events as a gauge

The metric reports the current count of events in the database, which drops when retention prunes old events. As a counter, each prune read as a counter reset, so increase() and rate() inflated event counts. The series name changes from frigate_camera_events_total to frigate_camera_events. The test's porch/inside assertion was missing its `in event.text` and always passed.

* keep uvicorn idle connections open longer than nginx's upstream keepalive

uvicorn closed idle connections after its 5s default while nginx kept them pooled for 60s, so a request nginx sent on a connection uvicorn was closing got a 502. nginx retries that on a fresh connection for most methods, but not for POST or PATCH.

* snapshot websocket clients under the manager lock in the output loop

The output loop iterated ws4py's live websocket dict without its lock, so a client connecting or disconnecting mid-iteration raised "dictionary changed size during iteration" and killed the output loop. It now copies the clients under manager.lock once per frame and skips terminated ones, matching the jsmpeg and birdseye broadcasters.

* only cache preview frames when recording is enabled

The segment-end check tested the record config object instead of record.enabled, and the first frame after startup was written unconditionally. With recording disabled, the first segment still cached frames and encoded a preview.

* fix untranslated unknown resolution text in camera info dialog

* detect all AMD GPUs from vainfo

The vainfo check only matched "AMD Radeon Graphics", so drivers reporting names like "AMD Radeon Vega 8 Graphics", "AMD Radeon RX 6600", "AMD Custom GPU 0405", or older codename strings fell through and their GPU stats were collected as Intel. It now matches Mesa's "for AMD" driver string.

* return a 500 instead of raising when go2rtc is unreachable

The two go2rtc stream GETs had no exception handling or timeout, so a go2rtc outage raised a connection error with a traceback, and a hung go2rtc held the request open indefinitely. Both now catch request errors, log the cause, and use a timeout. The per-stream probe gets a 35s read timeout because go2rtc probes each source in turn, and one unresponsive source takes about 10s.

* retry camera snapshots after a failed load

AutoUpdatingCameraImage only scheduled the next frame from onLoad, so a single failed latest.webp request froze the image until the component remounted. It now retries on error, dropping the periodic cache key so the retry requests a fresh URL.

* reuse pooled upstream connections for nginx auth subrequests

The /auth subrequest proxied to a variable address, which nginx can't pool, and its location-level headers dropped the inherited Connection header so nginx sent Connection: close. Every authenticated request opened and closed its own loopback connection to the API. It now proxies to the frigate_api upstream with an empty Connection header so the keepalive pool is reused.

2026-10-23 06:20:01 -06:00

4.4 KiB

Raw Blame History

id, title

id	title
metrics	Metrics

import ConfigTabs from "@site/src/components/ConfigTabs"; import TabItem from "@theme/TabItem"; import NavPath from "@site/src/components/NavPath";

Metrics

Frigate exposes Prometheus metrics at the /api/metrics endpoint that can be used to monitor the performance and health of your Frigate instance.

Enabling Telemetry

Prometheus metrics are exposed via the telemetry configuration. Enable or configure telemetry to control metric availability.

Navigate to to configure metrics and telemetry settings.

Metrics are available at /api/metrics by default. No additional Frigate configuration is required to expose them.

Available Metrics

System Metrics

frigate_cpu_usage_percent{pid="", name="", process="", type="", cmdline=""} - Process CPU usage percentage
frigate_mem_usage_percent{pid="", name="", process="", type="", cmdline=""} - Process memory usage percentage
frigate_gpu_usage_percent{gpu_name=""} - GPU utilization percentage
frigate_gpu_mem_usage_percent{gpu_name=""} - GPU memory usage percentage

Camera Metrics

frigate_camera_fps{camera_name=""} - Frames per second being consumed from your camera
frigate_detection_fps{camera_name=""} - Number of times detection is run per second
frigate_process_fps{camera_name=""} - Frames per second being processed
frigate_skipped_fps{camera_name=""} - Frames per second skipped for processing
frigate_detection_enabled{camera_name=""} - Detection enabled status for camera
frigate_audio_dBFS{camera_name=""} - Audio dBFS for camera
frigate_audio_rms{camera_name=""} - Audio RMS for camera

Detector Metrics

frigate_detector_inference_speed_seconds{name=""} - Time spent running object detection in seconds
frigate_detection_start{name=""} - Detector start time (unix timestamp)

Storage Metrics

frigate_storage_free_bytes{storage=""} - Storage free bytes
frigate_storage_total_bytes{storage=""} - Storage total bytes
frigate_storage_used_bytes{storage=""} - Storage used bytes
frigate_storage_mount_type{mount_type="", storage=""} - Storage mount type info

These gauges report the operating system's figures for the whole filesystem (the same numbers as df), not Frigate's own recording footprint. For how this differs from the recordings usage shown in the UI, see Understanding storage usage.

Service Metrics

frigate_service_uptime_seconds - Uptime in seconds
frigate_service_last_updated_timestamp - Stats recorded time (unix timestamp)
frigate_device_temperature{device=""} - Device Temperature

Event Metrics

frigate_camera_events{camera="", label=""} - Current number of events stored in the database for each camera and label

Configuring Prometheus

To scrape metrics from Frigate, add the following to your Prometheus configuration:

scrape_configs:
  - job_name: "frigate"
    metrics_path: "/api/metrics"
    static_configs:
      - targets: ["frigate:5000"]
    scrape_interval: 15s

Example Queries

Here are some example PromQL queries that might be useful:

# Average CPU usage across all processes
avg(frigate_cpu_usage_percent)

# Total GPU memory usage
sum(frigate_gpu_mem_usage_percent)

# Detection FPS by camera
rate(frigate_detection_fps{camera_name="front_door"}[5m])

# Storage usage percentage
(frigate_storage_used_bytes / frigate_storage_total_bytes) * 100

# Number of events currently stored in the database by camera
sum by (camera) (frigate_camera_events)

Grafana Dashboard

You can use these metrics to create Grafana dashboards to monitor your Frigate instance. Here's an example of metrics you might want to track:

CPU, Memory and GPU usage over time
Camera FPS and detection rates
Storage usage and trends
Event counts by camera
System temperatures

A sample Grafana dashboard JSON will be provided in a future update.

Metric Types

The metrics exposed by Frigate use the following Prometheus metric types:

Gauge: Values that can go up and down (e.g., frigate_cpu_usage_percent, frigate_camera_events)
Info: Key-value pairs for metadata (e.g., frigate_storage_mount_type)

For more information about Prometheus metric types, see the Prometheus documentation.

4.4 KiB Raw Blame History