Stackdriver Monitoring Client Libraries

This page shows how to get started with the new Cloud Client Libraries for the Stackdriver Monitoring API. Read more about the client libraries for Cloud APIs, including the older Google APIs Client Libraries, in Client Libraries Explained.

For information about the previous Stackdriver Monitoring API client libraries, see Stackdriver Monitoring API Client Libraries.

Installing the client library


In Visual Studio 2013/2015, open the Package Manager Console and run this command:
Install-Package Google.Cloud.Monitoring.V3 -Pre


go get -u


If you are using Maven, add this to your pom.xml file:
If you are using Gradle, add this to your dependencies:
compile ''
If you are using SBT, add this to your dependences:
libraryDependencies += "" % "google-cloud-monitoring" % "0.32.0-beta"


npm install --save @google-cloud/monitoring


composer require google/cloud-monitoring


For more on setting up your Python development environment, refer to Python Development Environment Setup Guide.
pip install --upgrade google-cloud-monitoring


gem install google-cloud-monitoring

Using the client library

To run the client library, you must first set up authentication.

The following example shows how to use the client library.


See for instructions on using Visual Studio to build and run this sample C# code.
using System;
using System.Collections.Generic;
using Google.Cloud.Monitoring.V3;
using Google.Protobuf.WellKnownTypes;
using Google.Api;

namespace GoogleCloudSamples
    public class QuickStart
        public static void Main(string[] args)
            // Your Google Cloud Platform project ID.
            string projectId = "YOUR-PROJECT-ID";

            // Create client.
            MetricServiceClient metricServiceClient = MetricServiceClient.Create();

            // Initialize request argument(s).
            ProjectName name = new ProjectName(projectId);

            // Prepare a data point. 
            Point dataPoint = new Point();
            TypedValue salesTotal = new TypedValue();
            salesTotal.DoubleValue = 123.45;
            dataPoint.Value = salesTotal;
            // Sets data point's interval end time to current time.
            Timestamp timeStamp = new Timestamp();
            DateTime UnixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
            timeStamp.Seconds = (long)(DateTime.UtcNow - UnixEpoch).TotalSeconds;
            TimeInterval interval = new TimeInterval();
            interval.EndTime = timeStamp;
            dataPoint.Interval = interval;

            // Prepare custom metric.
            Metric metric = new Metric();
            metric.Type = "";
            metric.Labels.Add("store_id", "Pittsburgh");

            // Prepare monitored resource.
            MonitoredResource resource = new MonitoredResource();
            resource.Type = "global";
            resource.Labels.Add("project_id", projectId);

            // Create a new time series using inputs.
            TimeSeries timeSeriesData = new TimeSeries();
            timeSeriesData.Metric = metric;
            timeSeriesData.Resource = resource;

            // Add newly created time series to list of time series to be written.
            IEnumerable<TimeSeries> timeSeries = new List<TimeSeries> { timeSeriesData };
            // Write time series data.
            metricServiceClient.CreateTimeSeries(name, timeSeries);
            Console.WriteLine("Done writing time series data.");
Read more in the C# API Reference Documentation for the Stackdriver Monitoring API Client Library.


// Sample monitoring-quickstart writes a data point to Stackdriver Monitoring.
package main

import (

	// Imports the Stackdriver Monitoring client package.
	monitoring ""
	googlepb ""
	metricpb ""
	monitoredrespb ""
	monitoringpb ""

func main() {
	ctx := context.Background()

	// Creates a client.
	client, err := monitoring.NewMetricClient(ctx)
	if err != nil {
		log.Fatalf("Failed to create client: %v", err)

	// Sets your Google Cloud Platform project ID.
	projectID := "YOUR_PROJECT_ID"

	// Prepares an individual data point
	dataPoint := &monitoringpb.Point{
		Interval: &monitoringpb.TimeInterval{
			EndTime: &googlepb.Timestamp{
				Seconds: time.Now().Unix(),
		Value: &monitoringpb.TypedValue{
			Value: &monitoringpb.TypedValue_DoubleValue{
				DoubleValue: 123.45,

	// Writes time series data.
	if err := client.CreateTimeSeries(ctx, &monitoringpb.CreateTimeSeriesRequest{
		Name: monitoring.MetricProjectPath(projectID),
		TimeSeries: []*monitoringpb.TimeSeries{
				Metric: &metricpb.Metric{
					Type: "",
					Labels: map[string]string{
						"store_id": "Pittsburg",
				Resource: &monitoredrespb.MonitoredResource{
					Type: "global",
					Labels: map[string]string{
						"project_id": projectID,
				Points: []*monitoringpb.Point{
	}); err != nil {
		log.Fatalf("Failed to write time series data: %v", err)

	fmt.Printf("Done writing time series data.\n")
Read more in the Go API Reference Documentation for the Stackdriver Monitoring API Client Library.



// Imports the Google Cloud client library


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class QuickstartSample {
  public static void main(String... args) throws Exception {
    // Your Google Cloud Platform project ID
    String projectId = System.getProperty("projectId");

    if (projectId == null) {
      System.err.println("Usage: QuickstartSample -DprojectId=YOUR_PROJECT_ID");

    // Instantiates a client
    MetricServiceClient metricServiceClient = MetricServiceClient.create();

    // Prepares an individual data point
    TimeInterval interval = TimeInterval.newBuilder()
    TypedValue value = TypedValue.newBuilder()
    Point point = Point.newBuilder()

    List<Point> pointList = new ArrayList<>();

    ProjectName name = ProjectName.create(projectId);

    // Prepares the metric descriptor
    Map<String, String> metricLabels = new HashMap<String, String>();
    metricLabels.put("store_id", "Pittsburg");
    Metric metric = Metric.newBuilder()

    // Prepares the monitored resource descriptor
    Map<String, String> resourceLabels = new HashMap<String, String>();
    resourceLabels.put("project_id", projectId);
    MonitoredResource resource = MonitoredResource.newBuilder()

    // Prepares the time series request
    TimeSeries timeSeries = TimeSeries.newBuilder()
    List<TimeSeries> timeSeriesList = new ArrayList<>();

    CreateTimeSeriesRequest request = CreateTimeSeriesRequest.newBuilder()

    // Writes time series data

    System.out.printf("Done writing time series data.%n");

Read more in the Java API Reference Documentation for the Stackdriver Monitoring API Client Library.


// Imports the Google Cloud client library
const monitoring = require('@google-cloud/monitoring');

// Your Google Cloud Platform project ID
const projectId = 'YOUR_PROJECT_ID';

// Creates a client
const client = new monitoring.MetricServiceClient();

// Prepares an individual data point
const dataPoint = {
  interval: {
    endTime: {
      seconds: / 1000,
  value: {
    // The amount of sales
    doubleValue: 123.45,

// Prepares the time series request
const request = {
  name: client.projectPath(projectId),
  timeSeries: [
      // Ties the data point to a custom metric
      metric: {
        type: '',
        labels: {
          store_id: 'Pittsburgh',
      resource: {
        type: 'global',
        labels: {
          project_id: projectId,
      points: [dataPoint],

// Writes time series data
  .then(results => {
    console.log(`Done writing time series data.`, results[0]);
  .catch(err => {
    console.error('ERROR:', err);
Read more in the Node.js API Reference Documentation for the Stackdriver Monitoring API Client Library.


# Includes the autoloader for libraries installed with composer
require_once __DIR__ . '/vendor/autoload.php';

# Imports the Google Cloud client library
use Google\Api\Metric;
use Google\Api\MonitoredResource;
use Google\Cloud\Monitoring\V3\MetricServiceClient;
use Google\Monitoring\V3\Point;
use Google\Monitoring\V3\TimeInterval;
use Google\Monitoring\V3\TimeSeries;
use Google\Monitoring\V3\TypedValue;
use Google\Protobuf\Timestamp;

// These variables are set by the App Engine environment. To test locally,
// ensure these are set or manually change their values.
$projectId = getenv('GCLOUD_PROJECT') ?: 'YOUR_PROJECT_ID';
$instanceId = '1234567890123456789';
$zone = 'us-central1-f';

try {
    $client = new MetricServiceClient();
    $formattedProjectName = $client->projectName($projectId);
    $labels = [
        'instance_id' => $instanceId,
        'zone' => $zone,

    $m = new Metric();

    $r = new MonitoredResource();

    $value = new TypedValue();

    $timestamp = new Timestamp();

    $interval = new TimeInterval();

    $point = new Point();
    $points = [$point];

    $timeSeries = new TimeSeries();

    $client->createTimeSeries($formattedProjectName, [$timeSeries]);
    print('Successfully submitted a time series' . PHP_EOL);
} finally {
Read more in the PHP API Reference Documentation for the Stackdriver Monitoring API Client Library.


from import monitoring

client = monitoring.Client()

resource = client.resource(
        'instance_id': '1234567890123456789',
        'zone': 'us-central1-f',

metric = client.metric(

# Default arguments use endtime datetime.utcnow()
client.write_point(metric, resource, 3.14)
print('Successfully wrote time series.')
Read more in the Python API Reference Documentation for the Stackdriver Monitoring API Client Library.

Additional Resources

Send feedback about...

Stackdriver Monitoring