Unlimited Learning, One Price
$299 / INR 23,999

from prometheus_client import CollectorRegistry, Gauge, push_to_gateway

registry = CollectorRegistry()
gauge = Gauge('my_custom_metric', 'A custom gauge metric', registry=registry)

def push_metrics():
    gauge.set(42)
    push_to_gateway(job='my_app', url='http://prometheus:9090/metrics', registry=registry)

while True:
    push_metrics()
    time.sleep(10)

from prometheus_client import CollectorRegistry, Gauge, push_to_gateway

registry = CollectorRegistry()
gauge = Gauge('my_custom_metric', 'A custom gauge metric', registry=registry)

def push_metrics():
    gauge.set(42)
    push_to_gateway(url='http://prometheus:9090/metrics', registry=registry)

while True:
    push_metrics()
    time.sleep(10)

from prometheus_client import CollectorRegistry, Gauge, push_to_gateway

registry = CollectorRegistry()
gauge = Gauge('my_custom_metric', 'A custom gauge metric', registry=registry)

def push_metrics():
    gauge.set(42)
    push_to_gateway(job='my_app', url='http://prometheus:9090/metrics', registry=registry, interval=10)

while True:
    push_metrics()
    time.sleep(10)

// Example in Go
import (
	"fmt"
	"net/http"
	"github.com/prometheus/client_golang/prometheus"
)

var (  
	logMessages = prometheus.NewCounterVec(  
		prometheus.CounterOpts{  
			Name: "log_messages_total",  
			Help: "Total number of log messages",  
		},  
		[]string{"severity"}, // Label for severity level
	)
)

func main() {
	// ... 
	
    http.HandleFunc("/metrics", handleMetrics)
    // ...
}

func handleMetrics(w http.ResponseWriter, r  http.Request) {
    // ...
    for _, message := range logMessages {
        fmt.Fprintf(w, "log_messages_total{severity="%s"} %f\n", message.severity, message.Value)
    }
    // ...
}

// Example in Python
from prometheus_client import Gauge
from prometheus_client import start_http_server

# Define the metric
log_messages = Gauge('log_messages_total', 'Total number of log messages', ['severity'])

# ...

# Create a function to handle log messages
def handle_log_message(severity):
    log_messages.labels(severity=severity).inc()

# ...

# Start the HTTP server
start_http_server(8080)
# ...

// Example in Ruby
require 'prometheus/client'  

# Define the metric
log_messages = Prometheus::Client.new  
	.counter(:log_messages_total, help: 'Total number of log messages', labels: :severity)  

# Function to handle log messages
def handle_log_message(severity)  
    log_messages.labels(severity: severity).inc  
end

# ...

# Start the HTTP server
require 'prometheus/client/exporter/http'  

Prometheus::Client::Exporter::HTTP.new(:port => 9090)  
.start  

scrape_configs:
- job_name: 'my-service-exporter'
  static_configs:
  - targets: ['exporter-host:9100']

scrape_configs:
- job_name: 'my-service-exporter'
  static_configs:
  - targets: ['exporter-host:9100/metrics']

scrape_configs:
- job_name: 'my-service-exporter'
  static_configs:
  - targets: ['exporter-host:9100']
  metrics_path: '/metrics'

// Example in Go
import (
	"fmt"
	"net/http"
	"github.com/prometheus/client_golang/prometheus"
)

var (  
	connections = prometheus.NewGaugeVec(  
		prometheus.GaugeOpts{  
			Name: "active_connections",  
			Help: "Number of active connections to the service",  
		},  
		[]string{"instance", "service"}, // Labels for instance and service
	)
)

func main() {
	// ... 
	
    http.HandleFunc("/metrics", handleMetrics)
    // ...
}

func handleMetrics(w http.ResponseWriter, r  http.Request) {
    // ...
    for _, instance := range instances {
        // Get the number of active connections for the instance
        connectionsCount := getConnectionsCount(instance)
        connections.WithLabelValues(instance, "my-service").Set(float64(connectionsCount))
    }
    // ...
}

// Example in Python
from prometheus_client import Gauge
from prometheus_client import start_http_server

# Define the metric
connections = Gauge('active_connections', 'Number of active connections to the service', ['instance', 'service'])

# ...

# Create a function to handle active connections
def handle_active_connections(instance, connectionsCount):
    connections.labels(instance=instance, service="my-service").set(connectionsCount)

# ...

# Start the HTTP server
start_http_server(8080)
# ...

// Example in Ruby
require 'prometheus/client'  

# Define the metric
connections = Prometheus::Client.new  
	.gauge(:active_connections, help: 'Number of active connections to the service', labels: [:instance, :service])  

# Function to handle active connections
def handle_active_connections(instance, connectionsCount)  
    connections.labels(instance: instance, service: "my-service").set(connectionsCount)  
end

# ...

# Start the HTTP server
require 'prometheus/client/exporter/http'  

Prometheus::Client::Exporter::HTTP.new(:port => 9090)  
.start  

http_requests_total{instance="server1"}

http_requests_total{server="server1"}

http_requests_total{instance="server2", instance="server3"}

avg by (instance) (mysql_connections_active)

avg_over_time(mysql_connections_active[5m])

increase(mysql_connections_active[5m])

groups: 'Application Errors'

rule: 'HighErrorRate'

expr: avg_over_time(app_errors_total[1m]) > 5

for: 1m

labels:

severity: 'warning'

groups: 'Application Errors'

rule: 'HighErrorRate'

expr: rate(app_errors_total[1m]) > 5

for: 1m

labels:

severity: 'warning'

groups: 'Application Errors'

rule: 'HighErrorRate'

expr: increase(app_errors_total[1m]) > 5

for: 1m

labels:

severity: 'warning'

histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[1h])) by (le))

quantile(0.95, http_request_duration_seconds)

topk(0.95, http_request_duration_seconds)

rate(http_request_duration_seconds[1m])   1000

http_request_duration_seconds   1000

sum(http_request_duration_seconds)   1000

groups: 'web_service_latency'
alert: ServiceLatencyHigh
  expr: avg_over_time(http_request_duration_seconds[5m]) > 0.5
  for: 5m
  labels: { severity: 'critical' }
  annotations: { description: 'The web service response time has exceeded 500ms for the past 5 minutes.' }

groups: 'web_service_latency'
alert: ServiceLatencyHigh
  expr: http_request_duration_seconds > 0.5
  for: 5m
  labels: { severity: 'critical' }
  annotations: { description: 'The web service response time has exceeded 500ms for the past 5 minutes.' }

groups: 'web_service_latency'
alert: ServiceLatencyHigh
  expr: quantile(http_request_duration_seconds, 0.95) > 0.5
  for: 5m
  labels: { severity: 'critical' }
  annotations: { description: 'The web service response time has exceeded 500ms for the past 5 minutes.' }

avg_over_time(cpu_usage_seconds_total[10m]) > 0.9

rate(cpu_usage_seconds_total[10m]) > 0.9

sum_over_time(cpu_usage_seconds_total[10m]) > 0.9

increase(login_failures_total[5m]) > 100

sum(login_failures_total[5m]) > 100

max_over_time(login_failures_total[5m]) > 100

groups: 'response_time_alert'
alert: ResponseTime99thPercentileHigh
  expr: quantile(http_request_duration_seconds, 0.99) > 2
  for: 3m
  labels: { severity: 'critical' }
  annotations: { description: '99th percentile of response time has exceeded 2 seconds for the past 3 minutes.' }

groups: 'response_time_alert'
alert: ResponseTime99thPercentileHigh
  expr: avg_over_time(http_request_duration_seconds[3m]) > 2
  for: 3m
  labels: { severity: 'critical' }
  annotations: { description: '99th percentile of response time has exceeded 2 seconds for the past 3 minutes.' }

groups: 'response_time_alert'
alert: ResponseTime99thPercentileHigh
  expr: rate(http_request_duration_seconds[3m]) > 2
  for: 3m
  labels: { severity: 'critical' }
  annotations: { description: '99th percentile of response time has exceeded 2 seconds for the past 3 minutes.' }

avg_over_time(node_filesystem_free_bytes{job='server', instance!='backup-server'}[1h]) < 0.2   node_filesystem_size_bytes{job='server'}

avg_over_time(node_filesystem_free_bytes{job='server', instance='backup-server'}[1h]) < 0.2   node_filesystem_size_bytes{job='server'}

avg_over_time(node_filesystem_free_bytes{job='server'}[1h]) < 0.2   node_filesystem_size_bytes{job='server'} or instance!='backup-server'

avg_over_time(node_cpu_seconds_total{mode='system',instance=~'. '}[15m]) > 0.8

avg_over_time(node_cpu_seconds_total{mode='system'}[15m]) > 0.8

sum(avg_over_time(node_cpu_seconds_total{mode='system'}[15m]) by (instance)) / count(node_cpu_seconds_total{mode='system'}) > 0.8