Implementing Custom Metrics

package main

import (
    "log"
    "net/http"

    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
    "github.com/prometheus/client_golang/prometheus/promhttp"
)

var (
    httpRequestCount = promauto.NewCounterVec(
        prometheus.CounterOpts{
            Name: "http_requests_total",
            Help: "Total number of HTTP requests",
        },
        []string{"method", "code"},
    )
)

func main() {
    http.Handle("/metrics", promhttp.Handler())
    http.HandleFunc("/hello", func(w http.ResponseWriter, r *http.Request) {
        httpRequestCount.WithLabelValues(r.Method, "200").Inc()
        w.Write([]byte("Hello, World!"))
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

from prometheus_client import Counter, start_http_server

# Create a counter metric
http_requests_total = Counter(
    "http_requests_total",
    "Total number of HTTP requests",
    [ "method", "code" ]
)

def handle_request():
    # Increment the counter
    http_requests_total.labels(method="GET", code="200").inc()
    return "Hello, World!"

if __name__ == "__main__":
    start_http_server(8080)

package main

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    httpRequestCount = promauto.NewCounterVec(prometheus.CounterOpts{
        Name: "http_requests_total",
        Help: "Total number of HTTP requests",
    }, []string{"method", "endpoint"})
)

func main() {
    // Increment counter on each request
    httpRequestCount.WithLabelValues("GET", "/api/users").Inc()
}

const client = require('prom-client');

const gauge = new client.Gauge({
  name: 'nodejs_heap_used_bytes',
  help: 'The number of bytes of the Node.js heap used',
});

// Set gauge value
gauge.set(process.memoryUsage().heapUsed);

// Increment gauge value
gauge.inc(1024); // Adds 1KB to the gauge

// Decrement gauge value
gauge.dec(512); // Removes 512 bytes from the gauge

const promClient = require('prom-client');

const histogram = new promClient.Histogram({
  name: 'request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'endpoint'],
  buckets: [0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10]
});

module.exports = histogram;

const start = Date.now();
// Simulate request processing
await processRequest();

const duration = (Date.now() - start) / 1000;
histogram.observe({ method: 'GET', endpoint: '/api/users' }, duration);

package main

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promauto"
)

var (
    requestDuration = promauto.NewSummary(prometheus.SummaryOpts{
        Name: "http_request_duration_seconds",
        Help: "Duration of HTTP requests in seconds",
        LabelNames: []string{"method", "endpoint"},
        MaxAge: 60 * time.Second,
        BufCap: 1000,
    })
)

func main() {
    // Example usage
    requestDuration.WithLabelValues("GET", "/api/users").Observe(0.5)
}

const client = require('prom-client');
const express = require('express');

const app = express();
const collectDefaultMetrics = client.collectDefaultMetrics;
const register = client.register;

// Collect default metrics
collectDefaultMetrics({ prefix: 'myapp_' });

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', register.contentType);
  res.end(await register.metrics());
});

app.listen(9090, () => {
  console.log('Metrics endpoint available at http://localhost:9090/metrics');
});

const Prometheus = require('prom-client');
const registry = new Prometheus.Registry();

const counter = new Prometheus.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'status']
});

registry.registerMetric(counter);

// Increment the counter
counter.inc({ method: 'GET', status: '200' });

const Prometheus = require('prom-client');
const registry = new Prometheus.Registry();

const histogram = new Prometheus.Histogram({
  name: 'request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'status'],
  buckets: [0.1, 0.5, 1, 2, 5]
});

registry.registerMetric(histogram);

// Observe a value
histogram.observe({ method: 'POST', status: '201' }, 0.3);

const httpRequestCounter = new client.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'endpoint', 'status']
});

// Incrementing the counter with labels
httpRequestCounter.labels({method: 'GET', endpoint: '/api/users', status: 'success'}).inc();

curl -X POST http://pushgateway:9091/metrics/job/batch_job/instance/batch_instance_1 \
  -d 'my_metric{label="value"} 42'

const client = require('prom-client');
const counter = new client.Counter({
  name: 'http_requests_total',
  help: 'Total number of HTTP requests',
  labelNames: ['method', 'code']
});

// Increment the counter
counter.inc({ method: 'GET', code: '200' });

const histogram = new client.Histogram({
  name: 'request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  buckets: [0.1, 0.5, 1, 2, 5]
});

// Observe a value
histogram.observe(0.3);

package main

import (
    "testing"
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/testutil"
)

var (
    customCounter = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "custom_requests_total",
            Help: "Total number of custom requests",
        },
        []string{"method", "endpoint"},
    )
)

func init() {
    prometheus.MustRegister(customCounter)
}

func TestCustomMetrics(t *testing.T) {
    customCounter.WithLabelValues("GET", "/api/users").Inc()
    customCounter.WithLabelValues("POST", "/api/users").Inc()

    expected := `# HELP custom_requests_total Total number of custom requests
# TYPE custom_requests_total counter
custom_requests_total{endpoint="/api/users",method="GET"} 1
custom_requests_total{endpoint="/api/users",method="POST"} 1
`
    if err := testutil.CollectAndCompare(customCounter, strings.NewReader(expected)); err != nil {
        t.Errorf("Unexpected metrics: %v", err)
    }
}