Demonstra como gravar métricas com o OpenCensus.
Mais informações
Para ver a documentação detalhada que inclui este exemplo de código, consulte:
Exemplo de código
Go
Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.
// metrics_quickstart is an example of exporting a custom metric from
// OpenCensus to Stackdriver.
package main
import (
"context"
"fmt"
"log"
"time"
"contrib.go.opencensus.io/exporter/stackdriver"
"go.opencensus.io/stats"
"go.opencensus.io/stats/view"
"golang.org/x/exp/rand"
)
var (
// The task latency in milliseconds.
latencyMs = stats.Float64("task_latency", "The task latency in milliseconds", "ms")
)
func main() {
ctx := context.Background()
// Register the view. It is imperative that this step exists,
// otherwise recorded metrics will be dropped and never exported.
v := &view.View{
Name: "task_latency_distribution",
Measure: latencyMs,
Description: "The distribution of the task latencies",
// Latency in buckets:
// [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
Aggregation: view.Distribution(0, 100, 200, 400, 1000, 2000, 4000),
}
if err := view.Register(v); err != nil {
log.Fatalf("Failed to register the view: %v", err)
}
// Enable OpenCensus exporters to export metrics
// to Stackdriver Monitoring.
// Exporters use Application Default Credentials to authenticate.
// See https://developers.google.com/identity/protocols/application-default-credentials
// for more details.
exporter, err := stackdriver.NewExporter(stackdriver.Options{})
if err != nil {
log.Fatal(err)
}
// Flush must be called before main() exits to ensure metrics are recorded.
defer exporter.Flush()
if err := exporter.StartMetricsExporter(); err != nil {
log.Fatalf("Error starting metric exporter: %v", err)
}
defer exporter.StopMetricsExporter()
// Record 100 fake latency values between 0 and 5 seconds.
for i := 0; i < 100; i++ {
ms := float64(5*time.Second/time.Millisecond) * rand.Float64()
fmt.Printf("Latency %d: %f\n", i, ms)
stats.Record(ctx, latencyMs.M(ms))
time.Sleep(1 * time.Second)
}
fmt.Println("Done recording metrics")
}
Java
Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.
import com.google.common.collect.Lists;
import io.opencensus.exporter.stats.stackdriver.StackdriverStatsExporter;
import io.opencensus.stats.Aggregation;
import io.opencensus.stats.BucketBoundaries;
import io.opencensus.stats.Measure.MeasureLong;
import io.opencensus.stats.Stats;
import io.opencensus.stats.StatsRecorder;
import io.opencensus.stats.View;
import io.opencensus.stats.View.Name;
import io.opencensus.stats.ViewManager;
import java.io.IOException;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.TimeUnit;
public class Quickstart {
private static final int EXPORT_INTERVAL = 70;
private static final MeasureLong LATENCY_MS =
MeasureLong.create("task_latency", "The task latency in milliseconds", "ms");
// Latency in buckets:
// [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
private static final BucketBoundaries LATENCY_BOUNDARIES =
BucketBoundaries.create(Lists.newArrayList(0d, 100d, 200d, 400d, 1000d, 2000d, 4000d));
private static final StatsRecorder STATS_RECORDER = Stats.getStatsRecorder();
public static void main(String[] args) throws IOException, InterruptedException {
// Register the view. It is imperative that this step exists,
// otherwise recorded metrics will be dropped and never exported.
View view =
View.create(
Name.create("task_latency_distribution"),
"The distribution of the task latencies.",
LATENCY_MS,
Aggregation.Distribution.create(LATENCY_BOUNDARIES),
Collections.emptyList());
ViewManager viewManager = Stats.getViewManager();
viewManager.registerView(view);
// Enable OpenCensus exporters to export metrics to Stackdriver Monitoring.
// Exporters use Application Default Credentials to authenticate.
// See https://developers.google.com/identity/protocols/application-default-credentials
// for more details.
StackdriverStatsExporter.createAndRegister();
// Record 100 fake latency values between 0 and 5 seconds.
Random rand = new Random();
for (int i = 0; i < 100; i++) {
long ms = (long) (TimeUnit.MILLISECONDS.convert(5, TimeUnit.SECONDS) * rand.nextDouble());
System.out.println(String.format("Latency %d: %d", i, ms));
STATS_RECORDER.newMeasureMap().put(LATENCY_MS, ms).record();
}
// The default export interval is 60 seconds. The thread with the StackdriverStatsExporter must
// live for at least the interval past any metrics that must be collected, or some risk being
// lost if they are recorded after the last export.
System.out.println(
String.format(
"Sleeping %d seconds before shutdown to ensure all records are flushed.",
EXPORT_INTERVAL));
Thread.sleep(TimeUnit.MILLISECONDS.convert(EXPORT_INTERVAL, TimeUnit.SECONDS));
}
}Node.js
Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.
'use strict';
const {globalStats, MeasureUnit, AggregationType} = require('@opencensus/core');
const {StackdriverStatsExporter} = require('@opencensus/exporter-stackdriver');
const EXPORT_INTERVAL = process.env.EXPORT_INTERVAL || 60;
const LATENCY_MS = globalStats.createMeasureInt64(
'task_latency',
MeasureUnit.MS,
'The task latency in milliseconds'
);
// Register the view. It is imperative that this step exists,
// otherwise recorded metrics will be dropped and never exported.
const view = globalStats.createView(
'task_latency_distribution',
LATENCY_MS,
AggregationType.DISTRIBUTION,
[],
'The distribution of the task latencies.',
// Latency in buckets:
// [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
[0, 100, 200, 400, 1000, 2000, 4000]
);
// Then finally register the views
globalStats.registerView(view);
// Enable OpenCensus exporters to export metrics to Stackdriver Monitoring.
// Exporters use Application Default Credentials (ADCs) to authenticate.
// See https://developers.google.com/identity/protocols/application-default-credentials
// for more details.
// Expects ADCs to be provided through the environment as ${GOOGLE_APPLICATION_CREDENTIALS}
// A Stackdriver workspace is required and provided through the environment as ${GOOGLE_PROJECT_ID}
const projectId = process.env.GOOGLE_PROJECT_ID;
// GOOGLE_APPLICATION_CREDENTIALS are expected by a dependency of this code
// Not this code itself. Checking for existence here but not retaining (as not needed)
if (!projectId || !process.env.GOOGLE_APPLICATION_CREDENTIALS) {
throw Error('Unable to proceed without a Project ID');
}
// The minimum reporting period for Stackdriver is 1 minute.
const exporter = new StackdriverStatsExporter({
projectId: projectId,
period: EXPORT_INTERVAL * 1000,
});
// Pass the created exporter to Stats
globalStats.registerExporter(exporter);
// Record 100 fake latency values between 0 and 5 seconds.
for (let i = 0; i < 100; i++) {
const ms = Math.floor(Math.random() * 5);
console.log(`Latency ${i}: ${ms}`);
globalStats.record([
{
measure: LATENCY_MS,
value: ms,
},
]);
}
/**
* The default export interval is 60 seconds. The thread with the
* StackdriverStatsExporter must live for at least the interval past any
* metrics that must be collected, or some risk being lost if they are recorded
* after the last export.
*/
setTimeout(() => {
console.log('Done recording metrics.');
globalStats.unregisterExporter(exporter);
}, EXPORT_INTERVAL * 1000);
Python
Para autenticar no Monitoring, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.
from random import random
import time
from opencensus.ext.stackdriver import stats_exporter
from opencensus.stats import aggregation
from opencensus.stats import measure
from opencensus.stats import stats
from opencensus.stats import view
# A measure that represents task latency in ms.
LATENCY_MS = measure.MeasureFloat(
"task_latency", "The task latency in milliseconds", "ms"
)
# A view of the task latency measure that aggregates measurements according to
# a histogram with predefined bucket boundaries. This aggregate is periodically
# exported to Stackdriver Monitoring.
LATENCY_VIEW = view.View(
"task_latency_distribution",
"The distribution of the task latencies",
[],
LATENCY_MS,
# Latency in buckets: [>=0ms, >=100ms, >=200ms, >=400ms, >=1s, >=2s, >=4s]
aggregation.DistributionAggregation([100.0, 200.0, 400.0, 1000.0, 2000.0, 4000.0]),
)
def main():
# Register the view. Measurements are only aggregated and exported if
# they're associated with a registered view.
stats.stats.view_manager.register_view(LATENCY_VIEW)
# Create the Stackdriver stats exporter and start exporting metrics in the
# background, once every 60 seconds by default.
exporter = stats_exporter.new_stats_exporter()
print('Exporting stats to project "{}"'.format(exporter.options.project_id))
# Register exporter to the view manager.
stats.stats.view_manager.register_exporter(exporter)
# Record 100 fake latency values between 0 and 5 seconds.
for num in range(100):
ms = random() * 5 * 1000
mmap = stats.stats.stats_recorder.new_measurement_map()
mmap.measure_float_put(LATENCY_MS, ms)
mmap.record()
print(f"Fake latency recorded ({num}: {ms})")
# Keep the thread alive long enough for the exporter to export at least
# once.
time.sleep(65)
if __name__ == "__main__":
main()
A seguir
Para pesquisar e filtrar amostras de código para outros produtos do Google Cloud, consulte o navegador de amostra do Google Cloud.