Harbor exposes some key metrics needed for operators and administrators to monitor how your Harbor instance is running in real time. Observability is a key feature for operating a service in production and using this data you can identify abnormal statuses and make informed decisions to fix issues when an error occurs. Harbor exposes metrics using the Prometheus data model so you can easily start scraping your Harbor instance’s metrics using Prometheus.

In Harbor v2.2 and later you are able to enable metrics in your Harbor configuration file. Harbor metrics are available at <harbor_instance>:<metrics_port>/<metrics_path> based on your configured values.

Harbor metrics show data related to

• Runtime information from the GO library
• Performance metrics about all API requests in core
• Number of requests in flight in core
• Metrics provided by the docker distribution itself
• Some data related to business logic which already exist in the Harbor database

Metrics are exposed by several Harbor components: exporter, core, jobservice, and registry. In addition to runtime and performance data, these components also expose Harbor specific metrics. The following sections list the available Harbor metrics.

Harbor Exporter Metrics

The exporter component metrics relate to your Harbor instance configuration and collects some data from the Harbor database. Metrics are available at <harbor_instance>:<metrics_port>/<metrics_path>.

Metrics exposed by the Harbor Exporter

Name	Description	Labels (Values)	Metric type
harbor_project_total	Total number of public and private projects	public (true,false)	gauge
harbor_project_repo_total	Total number of repositories in a project	public (true,false), project_name	gauge
harbor_project_member_total	Total number of members in a project	project_name	gauge
harbor_project_quota_usage_byte	Total used resources of a project	project_name	gauge
harbor_project_quota_byte	Quota set in a project	project_name	gauge
harbor_artifact_pulled	Number of images pulled in a project	project_name	gauge
harbor_project_artifact_total	Total number of artifacts type in a project	artifact_type , project_name, public (true,false)	gauge
harbor_health	Current status of Harbor		gauge
harbor_system_info	Information about your Harbor instance	auth_mode (db_auth, ldap_auth, uaa_auth, http_auth, oidc_auth), harbor_version, self_registration(true,false)	gauge
harbor_up	Running status of Harbor components	component (chartmuseum, core, database, jobservice, portal, redis, registry, registryctl, trivy)	gauge
harbor_task_queue_size	The total number of tasks per type in the queue	instance, job, type	gauge
harbor_task_queue_latency	How long ago the next job to be processed was enqueued per type	instance, job, type	gauge
harbor_task_scheduled_total	Number of scheduled tasks	instance, job	gauge
harbor_task_concurrency	Total number of concurrent tasks per type on a pool	instance, job, pool, type	gauge

Harbor Core Metrics

The following are metrics pulled from the Harbor core pod and are available at <harbor_instance>:<metrics_port>/<metrics_path>?comp=core.

Metrics exposed by Harbor Core

Name	Description	Labels (Values)	Metric type
harbor_core_http_inflight_requests	The total number of requests	operation (values from operationId in Harbor API. Some legacy endpoints do not have an operationId, so the label value is unknown)	gauge
harbor_core_http_request_duration_seconds	The time duration of the requests	method (GET, POST, HEAD, PATCH, PUT), operation (values from operationId in Harbor API. Some legacy endpoints do not have an operationId, so the label value is unknown), quantile	summary
harbor_core_http_request_total	The total number of requests	method (GET, POST, HEAD, PATCH, PUT), operation (values from operationId in Harbor API. Some legacy endpoints do not have an operationId, so the label value is unknown)	counter

Registry Metrics

The following are metrics pulled from the Docker distribution and are available at <harbor_instance>:<metrics_port>/<metrics_path>?comp=registry.

Metrics exposed by Harbor Core

Name	Description	Labels (Values)	Metric type
registry_http_in_flight_requests	The in-flight HTTP requests	handler	gauge
registry_http_request_duration_seconds_bucket registry_http_request_duration_seconds_sum registry_http_request_duration_seconds_count	The HTTP request latencies in seconds	handler, method (GET, POST, HEAD, PATCH, PUT), le	histogram
registry_http_request_size_bytes_bucket registry_http_request_size_bytes_sum registry_http_request_size_bytes_count	The HTTP request sizes in bytes	handler, le	histogram
registry_http_requests_total	Total number of HTTP requests made	code,handler,method,le	counter
registry_http_response_size_bytes_bucket registry_http_response_size_bytes_sum registry_http_response_size_bytes_count	The HTTP response sizes in bytes	handler,le	histogram
registry_storage_action_seconds_bucket registry_storage_action_seconds_sum registry_storage_action_seconds_count	The number of seconds that the storage action takes	action,driver,le	histogram
registry_storage_cache_total	The number of cache request received	type	gauge

Harbor Jobservice metrics

The following are metrics pulled from the Harbor Jobservice and are available at <harbor_instance>:<metrics_port>/<metrics_path>?comp=jobservice.

Metrics exposed by Harbor Jobservice

Name	Description	Labels (Values)	Metric type
harbor_jobservice_info	The information of Jobservice	instance, job, node, pool, workers	gauge
harbor_jobservice_task_total	The number of processed tasks per job type	instance, job, status, type	counter
harbor_jobservice_task_process_time_seconds	The duration of the task processing time	instance, job, quantile, status, type	summary

Scraping Metrics with Prometheus

To begin accessing your Harbor instance’s metrics with Prometheus,

1. Enable exposing metrics in your harbor.yml configuration file and set the port and path for metrics to be exposed on. Also see more about reconfiguring your Harbor instance.

2. Set up a Prometheus server, see the Prometheus documentation for more information on installing.

3. Configure your Prometheus config file to scrape Harbor metrics exposed at your configured port and path. Below is an example scrape config, see the Prometheus documentation for all available scrape configuration options.

     scrape_configs:
   
       - job_name: 'harbor-exporter'
         scrape_interval: 20s
         static_configs:
           # Scrape metrics from the Harbor exporter component
           - targets: ['<harbor_instance>:<metrics_port>']
   
       - job_name: 'harbor-core'
         scrape_interval: 20s
         params:
           # Scrape metrics from the Harbor core component
           comp: ['core']
         static_configs:
           - targets: ['<harbor_instance>:<metrics_port>']
   
       - job_name: 'harbor-registry'
         scrape_interval: 20s
         params:
           # Scrape metrics from the Harbor registry component
           comp: ['registry']
         static_configs:
           - targets: ['<harbor_instance>:<metrics_port>']
   
       - job_name: 'harbor-jobservice'
         scrape_interval: 20s
         params:
           # Scrape metrics from the Harbor jobservice component
           comp: ['jobservice']
         static_configs:
           - targets: ['<harbor_instance>:<metrics_port>']
   

4. Once you have configured your Prometheus server to collect your Harbor metrics, you can use Grafana to visualize your data. An example Grafana dashboard is available in the Harbor repo to help you get started visualizing Harbor metrics.

From a Kubernetes cluster

You can also use Prometheus to collect metrics from a Harbor instance deployed in your Kubernetes cluster. You should already have installed Prometheus and set up to pull metrics from your cluster.

1. Create a ServiceMonitor in Prometheus for Harbor.

   apiVersion: monitoring.coreos.com/v1
   kind: ServiceMonitor
   metadata:
     name: harbor
     labels:
       app: harbor
   spec:
     selector:
       matchLabels:
         app: harbor
     endpoints:
     - port: metrics
   

2. Enable Harbor to expose metrics by updating your harbor-helm values.yaml file and set metrics.enabled to true. You can also edit the port and path the metrics are exposed on by updating the available harbor-helm chart configuration options for metrics.

Prometheus should now show your Harbor instance’s metrics.