You need to enable JavaScript to run this app.
Volcengine Managed Service for Prometheus

Volcengine Managed Service for Prometheus

  • Documentation
    • Volcengine Managed Service for PrometheusIntegration GuidePrometheus ecosystem integrationCustom integrationCustom business access
Copy page
Download PDF
Custom integration
Custom business access
Copy page
Download PDF
Custom business access
This topic takes the Go language as an example to introduce how to configure custom metric tracking for your business, and report, visualize, and alert custom metrics by using Volcengine Managed Service for Prometheus (VMP).​
Business metric tracking​
tip​
For the data format and metric type of Prometheus, refer to Format of Prometheus time series data.​
Counter​
A metric in the counter type increases monotonically and will be reset after service restart. You can use a counter to monitor the numbers of requests, exceptions, user logins, and orders.​
The following example shows how to monitor tickets by using the counter type.​
​
// Ticket​
package ticket​
​
import (​
"github.com/prometheus/client_golang/prometheus"​
)​
​
// The number of requests.​
var requestCounter = prometheus.NewCounterVec(prometheus.CounterOpts{​
Subsystem: "ticket",​
Name: "request_total",​
Help: "The total number of ticket requests.",​
}, []string{"action"}) // Actions​
​
func init() {​
prometheus.DefaultRegisterer.MustRegister(requestCounter)​
}​
​
// Create a ticket.​
func Create() {​
requestCounter.With(prometheus.Labels{"action": "create"}).Inc()​
​
// Create ticket code.​
}​
​
In this case, the creation rate of tickets can be obtained through the rate() function.​
​
rate(ticket_request_total{action="create"}[5m])​
​
Gauge type​
A gauge is a current value, which can be increased or decreased at the metric scrape time. You can use a gauge to monitor the current memory usage, CPU usage, current number of threads, and queue size.​
The following example shows how to monitor tickets by using a gauge.​
​
// Ticket​
package ticket​
​
import (​
"time"​
​
"github.com/prometheus/client_golang/prometheus"​
)​
​
var (​
createConcurrencyCh = make(chan struct{}, 8)​
)​
​
// Concurrency control​
var (​
createConcurrencyCurrent = prometheus.NewGaugeFunc(prometheus.GaugeOpts{​
Subsystem: "ticket",​
Name: "concurrent_create_current",​
Help: "The number of in-flight create ticket requests.",​
}, func() float64 { return float64(len(createConcurrencyCh)) })​
createConcurrencyCapacity = prometheus.NewGaugeFunc(prometheus.GaugeOpts{​
Subsystem: "ticket",​
Name: "concurrent_create_capacity",​
Help: "The maximum number of concurrent create ticket requests the server may serve.",​
}, func() float64 { return float64(cap(createConcurrencyCh)) })​
)​
​
func init() {​
prometheus.DefaultRegisterer.MustRegister(createConcurrencyCurrent, createConcurrencyCapacity)​
}​
​
// Create a ticket.​
func Create() {​
t := time.NewTimer(30 * time.Second)​
​
select {​
case createConcurrencyCh <- struct{}{}:​
case <-t.C:​
// timeout​
return​
}​
​
defer func() {​
<-createConcurrencyCh​
}()​
​
// Create ticket code.​
​
}​
​
In this case, you can view the concurrency saturation of tickets.​
​
max_over_time(ticket_concurrent_create_current[1m]) / ticket_concurrent_create_capacity​
​
Histogram type​
Prometheus calculates sample distribution based on the configured Bucket to generate a histogram, which can be processed subsequently and is generally used for duration monitoring. For example, you can use a histogram to calculate the latencies of P99, P95, and P50 and monitor the numbers of processed items. With histograms, you do not need to use counters to count items. In addition, you can use histograms to monitor metrics such as API response time and database access time.​
The following example shows how to monitor the duration of a ticket by using a histogram.​
​
// Ticket​
package ticket​
​
import (​
"time"​
​
"github.com/prometheus/client_golang/prometheus"​
)​
​
// Request duration​
var requestDuration = prometheus.HistogramVec(prometheus.HistogramOpts{​
Subsystem: "ticket",​
Name: "request_duration_seconds",​
Help: "Request duration distribution in seconds.",​
Buckets: prometheus.DefBuckets,​
}, []string{"action"}) // Actions​
​
func init() {​
prometheus.DefaultRegisterer.MustRegister(requestDuration)​
}​
​
// Create a ticket.​
func Create() {​
start := time.Now()​
defer requestDuration.With(prometheus.Labels{"action": "create"}).Observe(time.Since(start).Seconds())​
​
// Create ticket code.​
}​
​
In this case, you can view the latencies of P95 for the ticket by using a histogram.​
​
histogram_quantile(0.95, rate(ticket_request_duration_seconds_bucket{action="create"}[5m]))​
​
Summary type​
A summary is similar to a histogram because it also calculates sample distribution. However, a summary uses more client resources and the data cannot be calculated and processed in an aggregated manner subsequently because the summary calculates the distribution (P99/P95/Sum/Count) on the client. You can also use summaries to monitor metrics such as API response time and database access time.​
A summary can be used in a similar way to a histogram, so you can directly refer to the histogram usage.​
Expose Prometheus metrics​
Use promhttp.Handler() to expose the metric tracking data to the HTTP service.​
​
package main​
​
import (​
"net/http"​
​
"github.com/prometheus/client_golang/prometheus/promhttp"​
)​
​
func main() {​
// Business code​
​
// Expose Prometheus metrics to an HTTP service.​
http.Handle("/metrics", promhttp.Handler())​
​
// Business code​
}​
​
Deploy business​
After you configure custom metric tracking for your business, you can deploy an application in a VKE cluster or an ECS instance to release the application. After the application is released, you can access VMP to obtain metric data.​
service discovery​
When your business is deployed in different environments, different service discovery types are supported.​
  • When your business is deployed in a VKE cluster, you can use PodMonitor or ServiceMonitor for service discovery. For more details, refer to Service discovery.​
  • When your business is deployed in an ECS instance, you can use the integration center for service discovery. For more details, refer to ECS integration.​
View monitoring data​
You can view metric data by using the Explore feature of VMP. For more details, refer to Querying metrics.​
You can also use self-built Grafana to read data stored in VMP and create metric dashboards. For more details, refer to the following topics:​
​
Last updated: 2026.10.10 10:16:50