Custom metrics

# The first argument is a string, the second argument a number
# Appsignal.set_gauge(metric_name, value)
Appsignal.set_gauge("database_size", 100)
Appsignal.set_gauge("database_size", 10)
 
# Will create the metric "database_size" with the value 10

const meter = Appsignal.client.metrics();
 
// The first argument is a string, the second argument a number
// meter.setGauge(metric_name, value)
meter.setGauge("database_size", 100);
meter.setGauge("database_size", 10);
 
// Will create the metric "database_size" with the value 10

# Import the AppSignal metric helper
from appsignal import set_gauge
 
# The first argument is a string, the second argument a number (int/float)
# set_gauge(metric_name, value)
set_gauge("database_size", 100)
set_gauge("database_size", 10)
 
# Will create the metric named "database_size" with the value 10

<?php
use OpenTelemetry\API\Globals;
 
// Get the meter from the global meter provider
$meterProvider = Globals::meterProvider();
$meter = $meterProvider->getMeter('my-app');
 
// Create a gauge instrument
$gauge = $meter->createGauge('database_size');
 
// Record gauge values
$gauge->record(100);
$gauge->record(10);
 
// Will create the metric "database_size" with the value 10

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.metrics.DoubleGauge;
import io.opentelemetry.api.metrics.Meter;
 
public void recordMetrics() {
    // Get the meter from the global meter provider
    Meter meter = GlobalOpenTelemetry.getMeter("my-app");
 
    // Create a gauge instrument
    DoubleGauge gauge = meter.gaugeBuilder("database_size").build();
 
    // Record gauge values
    gauge.set(100);
    gauge.set(10);
 
    // Will create the metric "database_size" with the value 10
}

package main
 
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/metric"
)
 
func recordMetrics() {
	// Get the meter from the global meter provider
	meter := otel.Meter("my-app")
 
	// Create a gauge instrument
	gauge, _ := meter.Float64Gauge("database_size")
 
	// Record gauge values
	gauge.Record(context.Background(), 100)
	gauge.Record(context.Background(), 10)
 
	// Will create the metric "database_size" with the value 10
}

# The first argument is a string, the second argument a number
# Appsignal.add_distribution_value(metric_name, value)
Appsignal.add_distribution_value("memory_usage", 100)
Appsignal.add_distribution_value("memory_usage", 110)
 
# Will create a metric "memory_usage" with the mean field value 105
# Will create a metric "memory_usage" with the count field value 2

const meter = Appsignal.client.metrics();
 
// The first argument is a string, the second argument a number
// meter.addDistributionValue(metric_name, value)
meter.addDistributionValue("memory_usage", 100);
meter.addDistributionValue("memory_usage", 110);
 
// Will create a metric "memory_usage" with the mean field value 105
// Will create a metric "memory_usage" with the count field value 2

# Import the AppSignal metric helper
from appsignal import add_distribution_value
 
# The first argument is a string, the second argument a number (int/float)
# add_distribution_value(metric_name, value)
add_distribution_value("memory_usage", 100)
add_distribution_value("memory_usage", 110)
 
# Will create a metric "memory_usage" with the mean field value 105
# Will create a metric "memory_usage" with the count field value 2

<?php
use OpenTelemetry\API\Globals;
 
// Get the meter from the global meter provider
$meterProvider = Globals::meterProvider();
$meter = $meterProvider->getMeter('my-app');
 
// Create a histogram instrument for distributions
$histogram = $meter->createHistogram('memory_usage');
 
// Record distribution values
$histogram->record(100);
$histogram->record(110);
 
// Will create a metric "memory_usage" with the mean field value 105
// Will create a metric "memory_usage" with the count field value 2

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.metrics.DoubleHistogram;
import io.opentelemetry.api.metrics.Meter;
 
public void recordDistributions() {
    // Get the meter from the global meter provider
    Meter meter = GlobalOpenTelemetry.getMeter("my-app");
 
    // Create a histogram instrument for distributions
    DoubleHistogram histogram = meter.histogramBuilder("memory_usage").build();
 
    // Record distribution values
    histogram.record(100);
    histogram.record(110);
 
    // Will create a metric "memory_usage" with the mean field value 105
    // Will create a metric "memory_usage" with the count field value 2
}

package main
 
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/metric"
)
 
func recordDistributions() {
	// Get the meter from the global meter provider
	meter := otel.Meter("my-app")
 
	// Create a histogram instrument for distributions
	histogram, _ := meter.Float64Histogram("memory_usage")
 
	// Record distribution values
	histogram.Record(context.Background(), 100)
	histogram.Record(context.Background(), 110)
 
	// Will create a metric "memory_usage" with the mean field value 105
	// Will create a metric "memory_usage" with the count field value 2
}

# The first argument is a string, the second argument a number
# Appsignal.increment_counter(metric_name, value)
Appsignal.increment_counter("login_count", 1)
Appsignal.increment_counter("login_count", 1)
 
# Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution

const meter = Appsignal.client.metrics();
 
// The first argument is a string, the second argument a number
// meter.incrementCounter(metric_name, value)
meter.incrementCounter("login_count", 1);
meter.incrementCounter("login_count", 1);
 
// Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution

# Import the AppSignal metric helper
from appsignal import increment_counter
 
# The first argument is a string, the second argument a number (int/float)
# increment_counter(metric_name, value)
increment_counter("metric_name", 1)  # Increase the value by one
increment_counter("metric_name", 1)
increment_counter("metric_name", -1) # Decrease the value by one
 
# Will create the metric named "metric_name" with the value 2 for a point in the minutely/hourly resolution

<?php
use OpenTelemetry\API\Globals;
 
// Get the meter from the global meter provider
$meterProvider = Globals::meterProvider();
$meter = $meterProvider->getMeter('my-app');
 
// Create a counter instrument
$counter = $meter->createCounter('login_count');
 
// Record counter values
$counter->add(1);
$counter->add(1);
 
// Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.metrics.LongCounter;
import io.opentelemetry.api.metrics.Meter;
 
public void recordCounters() {
    // Get the meter from the global meter provider
    Meter meter = GlobalOpenTelemetry.getMeter("my-app");
 
    // Create a counter instrument
    LongCounter counter = meter.counterBuilder("login_count").build();
 
    // Record counter values
    counter.add(1);
    counter.add(1);
 
    // Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
}

package main
 
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/metric"
)
 
func recordCounters() {
	// Get the meter from the global meter provider
	meter := otel.Meter("my-app")
 
	// Create a counter instrument
	counter, _ := meter.Int64Counter("login_count")
 
	// Record counter values
	counter.Add(context.Background(), 1)
	counter.Add(context.Background(), 1)
 
	// Will create the metric "login_count" with the value 2 for a point in the minutely/hourly resolution
}

# Integer
Appsignal.increment_counter("login_count", 1)
# Double
Appsignal.increment_counter("assignment_completed", 0.12)

const meter = Appsignal.client.metrics();
 
// Integer
meter.incrementCounter("login_count", 1);
// Double
meter.incrementCounter("assignment_completed", 0.12);

from appsignal import increment_counter
 
# Integer
increment_counter("login_count", 1)
# Double
increment_counter("assignment_completed", 0.12)

<?php
use OpenTelemetry\API\Globals;
 
$meterProvider = Globals::meterProvider();
$meter = $meterProvider->getMeter('my-app');
$counter = $meter->createCounter('login_count');
 
// Integer
$counter->add(1);
// Double
$counter->add(0.12);

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.metrics.DoubleCounter;
import io.opentelemetry.api.metrics.LongCounter;
import io.opentelemetry.api.metrics.Meter;
 
public void recordValues() {
    Meter meter = GlobalOpenTelemetry.getMeter("my-app");
 
    // Integer counter
    LongCounter longCounter = meter.counterBuilder("login_count").build();
    longCounter.add(1);
 
    // Double counter
    DoubleCounter doubleCounter = meter.counterBuilder("assignment_completed")
        .ofDoubles()
        .build();
    doubleCounter.add(0.12);
}

package main
 
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/metric"
)
 
func recordValues() {
	meter := otel.Meter("my-app")
 
	// Integer counter
	intCounter, _ := meter.Int64Counter("login_count")
	intCounter.Add(context.Background(), 1)
 
	// Float counter
	floatCounter, _ := meter.Float64Counter("assignment_completed")
	floatCounter.Add(context.Background(), 0.12)
}

Appsignal.set_gauge("database_size", 1024)

const meter = Appsignal.client.metrics();
 
meter.setGauge("database_size", 1024);

# Import the AppSignal metric helper
from appsignal import set_gauge
 
set_gauge("database_size", 1024)

<?php
use OpenTelemetry\API\Globals;
 
$meterProvider = Globals::meterProvider();
$meter = $meterProvider->getMeter('my-app');
$gauge = $meter->createGauge('database_size');
 
$gauge->record(1024);

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.metrics.DoubleGauge;
import io.opentelemetry.api.metrics.Meter;
 
public void recordFileSize() {
    Meter meter = GlobalOpenTelemetry.getMeter("my-app");
    DoubleGauge gauge = meter.gaugeBuilder("database_size").build();
 
    gauge.set(1024);
}

package main
 
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/metric"
)
 
func recordFileSize() {
	meter := otel.Meter("my-app")
	gauge, _ := meter.Float64Gauge("database_size")
 
	gauge.Record(context.Background(), 1024)
}

Appsignal.set_gauge("database_size", 100, %{region: "eu"})
Appsignal.set_gauge("database_size",  50, %{region: "us"})
Appsignal.set_gauge("database_size", 200, %{region: "asia"})
 
# Multiple tags per metric
Appsignal.set_gauge("my_metric_name", 100, %{tag_a: "a", tag_b: "b"})
Appsignal.set_gauge("my_metric_name", 10, %{tag_a: "a", tag_b: "b"})
Appsignal.set_gauge("my_metric_name", 200, %{tag_a: "b", tag_b: "c"})

const meter = Appsignal.client.metrics();
 
meter.setGauge("database_size", 100, { region: "eu" });
meter.setGauge("database_size", 50, { region: "us" });
meter.setGauge("database_size", 200, { region: "asia" });
 
// Multiple tags per metric
meter.setGauge("my_metric_name", 100, { tag_a: "a", tag_b: "b" });
meter.setGauge("my_metric_name", 10, { tag_a: "a", tag_b: "b" });
meter.setGauge("my_metric_name", 200, { tag_a: "b", tag_b: "c" });

from appsignal import set_gauge
 
set_gauge("database_size", 100, {"region": "eu"})
set_gauge("database_size",  50, {"region": "us"})
set_gauge("database_size", 200, {"region": "asia"})
 
# Multiple tags per metric
set_gauge("my_metric_name", 100, {"tag_a": "a", "tag_b": "b"})
set_gauge("my_metric_name",  10, {"tag_a": "a", "tag_b": "b"})
set_gauge("my_metric_name", 200, {"tag_a": "b", "tag_b": "c"})

<?php
use OpenTelemetry\API\Globals;
 
$meterProvider = Globals::meterProvider();
$meter = $meterProvider->getMeter('my-app');
$gauge = $meter->createGauge('database_size');
 
// Record gauge values with attributes (tags)
$gauge->record(100, ['region' => 'eu']);
$gauge->record(50, ['region' => 'us']);
$gauge->record(200, ['region' => 'asia']);
 
// Multiple tags per metric
$myGauge = $meter->createGauge('my_metric_name');
$myGauge->record(100, ['tag_a' => 'a', 'tag_b' => 'b']);
$myGauge->record(10, ['tag_a' => 'a', 'tag_b' => 'b']);
$myGauge->record(200, ['tag_a' => 'b', 'tag_b' => 'c']);

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.metrics.DoubleGauge;
import io.opentelemetry.api.metrics.Meter;
 
public void recordTaggedMetrics() {
    Meter meter = GlobalOpenTelemetry.getMeter("my-app");
    DoubleGauge gauge = meter.gaugeBuilder("database_size").build();
 
    // Record gauge values with attributes (tags)
    gauge.set(100, Attributes.of(
        AttributeKey.stringKey("region"), "eu"
    ));
    gauge.set(50, Attributes.of(
        AttributeKey.stringKey("region"), "us"
    ));
    gauge.set(200, Attributes.of(
        AttributeKey.stringKey("region"), "asia"
    ));
 
    // Multiple tags per metric
    DoubleGauge myGauge = meter.gaugeBuilder("my_metric_name").build();
    myGauge.set(100, Attributes.of(
        AttributeKey.stringKey("tag_a"), "a",
        AttributeKey.stringKey("tag_b"), "b"
    ));
    myGauge.set(10, Attributes.of(
        AttributeKey.stringKey("tag_a"), "a",
        AttributeKey.stringKey("tag_b"), "b"
    ));
    myGauge.set(200, Attributes.of(
        AttributeKey.stringKey("tag_a"), "b",
        AttributeKey.stringKey("tag_b"), "c"
    ));
}

package main
 
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/metric"
)
 
func recordTaggedMetrics() {
	meter := otel.Meter("my-app")
	gauge, _ := meter.Float64Gauge("database_size")
 
	// Record gauge values with attributes (tags)
	gauge.Record(context.Background(), 100, metric.WithAttributes(
		attribute.String("region", "eu"),
	))
	gauge.Record(context.Background(), 50, metric.WithAttributes(
		attribute.String("region", "us"),
	))
	gauge.Record(context.Background(), 200, metric.WithAttributes(
		attribute.String("region", "asia"),
	))
 
	// Multiple tags per metric
	myGauge, _ := meter.Float64Gauge("my_metric_name")
	myGauge.Record(context.Background(), 100, metric.WithAttributes(
		attribute.String("tag_a", "a"),
		attribute.String("tag_b", "b"),
	))
	myGauge.Record(context.Background(), 10, metric.WithAttributes(
		attribute.String("tag_a", "a"),
		attribute.String("tag_b", "b"),
	))
	myGauge.Record(context.Background(), 200, metric.WithAttributes(
		attribute.String("tag_a", "b"),
		attribute.String("tag_b", "c"),
	))
}

Appsignal.increment_counter("sign_ups", 1, %{region: "eu"})
Appsignal.increment_counter("sign_ups", 1)

const meter = Appsignal.client.metrics();
 
meter.incrementCounter("sign_ups", 1, { region: "eu" });
meter.incrementCounter("sign_ups", 1);

from appsignal import increment_counter
 
increment_counter("sign_ups", 1, {"region": "eu"})
increment_counter("sign_ups", 1)

<?php
use OpenTelemetry\API\Globals;
 
$meterProvider = Globals::meterProvider();
$meter = $meterProvider->getMeter('my-app');
$counter = $meter->createCounter('sign_ups');
 
$counter->add(1, ['region' => 'eu']);
$counter->add(1);

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.metrics.LongCounter;
import io.opentelemetry.api.metrics.Meter;
 
public void recordMixedMetrics() {
    Meter meter = GlobalOpenTelemetry.getMeter("my-app");
    LongCounter counter = meter.counterBuilder("sign_ups").build();
 
    counter.add(1, Attributes.of(
        AttributeKey.stringKey("region"), "eu"
    ));
    counter.add(1);
}

package main
 
import (
	"context"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/metric"
)
 
func recordMixedMetrics() {
	meter := otel.Meter("my-app")
	counter, _ := meter.Int64Counter("sign_ups")
 
	counter.Add(context.Background(), 1, metric.WithAttributes(
		attribute.String("region", "eu"),
	))
	counter.Add(context.Background(), 1)
}