時系列データを取得する

public static object ReadTimeSeriesFields(string projectId,     string metricType = "compute.googleapis.com/instance/cpu/utilization") {     Console.WriteLine($"metricType{ metricType}");     // Create client.     MetricServiceClient metricServiceClient = MetricServiceClient.Create();     // Initialize request argument(s).     string filter = $"metric.type=\"{metricType}\"";     ListTimeSeriesRequest request = new ListTimeSeriesRequest     {         ProjectName = new ProjectName(projectId),         Filter = filter,         Interval = new TimeInterval(),         View = ListTimeSeriesRequest.Types.TimeSeriesView.Headers,     };     // Create timestamp for current time formatted in seconds.     long timeStamp = (long)(DateTime.UtcNow - s_unixEpoch).TotalSeconds;     Timestamp startTimeStamp = new Timestamp();     // Set startTime to limit results to the last 20 minutes.     startTimeStamp.Seconds = timeStamp - (60 * 20);     Timestamp endTimeStamp = new Timestamp();     // Set endTime to current time.     endTimeStamp.Seconds = timeStamp;     TimeInterval interval = new TimeInterval();     interval.StartTime = startTimeStamp;     interval.EndTime = endTimeStamp;     request.Interval = interval;     // Make the request.     PagedEnumerable<ListTimeSeriesResponse, TimeSeries> response =         metricServiceClient.ListTimeSeries(request);     // Iterate over all response items, lazily performing RPCs as required.     Console.Write("Found data points for the following instances:");     foreach (var item in response)     {         Console.WriteLine(JObject.Parse($"{item}").ToString());     }     return 0; } 

import ( 	"context" 	"fmt" 	"io" 	"time"  	monitoring "cloud.google.com/go/monitoring/apiv3" 	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb" 	"github.com/golang/protobuf/ptypes/timestamp" 	"google.golang.org/api/iterator" )  // readTimeSeriesFields reads the last 20 minutes of the given metric, aligns // everything on 10 minute intervals, and combines values from different // instances. func readTimeSeriesFields(w io.Writer, projectID string) error { 	ctx := context.Background() 	client, err := monitoring.NewMetricClient(ctx) 	if err != nil { 		return fmt.Errorf("NewMetricClient: %w", err) 	} 	defer client.Close() 	startTime := time.Now().UTC().Add(time.Minute * -20) 	endTime := time.Now().UTC() 	req := &monitoringpb.ListTimeSeriesRequest{ 		Name:   "projects/" + projectID, 		Filter: `metric.type="compute.googleapis.com/instance/cpu/utilization"`, 		Interval: &monitoringpb.TimeInterval{ 			StartTime: &timestamp.Timestamp{ 				Seconds: startTime.Unix(), 			}, 			EndTime: &timestamp.Timestamp{ 				Seconds: endTime.Unix(), 			}, 		}, 		View: monitoringpb.ListTimeSeriesRequest_HEADERS, 	} 	fmt.Fprintln(w, "Found data points for the following instances:") 	it := client.ListTimeSeries(ctx, req) 	for { 		resp, err := it.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return fmt.Errorf("could not read time series value: %w", err) 		} 		fmt.Fprintf(w, "\t%v\n", resp.GetMetric().GetLabels()["instance_name"]) 	} 	fmt.Fprintln(w, "Done") 	return nil } 

String projectId = System.getProperty("projectId"); ProjectName name = ProjectName.of(projectId);  // Restrict time to last 20 minutes long startMillis = System.currentTimeMillis() - ((60 * 20) * 1000); TimeInterval interval =     TimeInterval.newBuilder()         .setStartTime(Timestamps.fromMillis(startMillis))         .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))         .build();  ListTimeSeriesRequest.Builder requestBuilder =     ListTimeSeriesRequest.newBuilder()         .setName(name.toString())         .setFilter("metric.type=\"compute.googleapis.com/instance/cpu/utilization\"")         .setInterval(interval)         .setView(ListTimeSeriesRequest.TimeSeriesView.HEADERS);  ListTimeSeriesRequest request = requestBuilder.build();  try (final MetricServiceClient client = MetricServiceClient.create();) {   ListTimeSeriesPagedResponse response = client.listTimeSeries(request);   System.out.println("Got timeseries headers: ");   for (TimeSeries ts : response.iterateAll()) {     System.out.println(ts);   } }

// Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.MetricServiceClient();  async function readTimeSeriesFields() {   /**    * TODO(developer): Uncomment and edit the following lines of code.    */   // const projectId = 'YOUR_PROJECT_ID';    const request = {     name: client.projectPath(projectId),     filter: 'metric.type="compute.googleapis.com/instance/cpu/utilization"',     interval: {       startTime: {         // Limit results to the last 20 minutes         seconds: Date.now() / 1000 - 60 * 20,       },       endTime: {         seconds: Date.now() / 1000,       },     },     // Don't return time series data, instead just return information about     // the metrics that match the filter     view: 'HEADERS',   };    // Writes time series data   const [timeSeries] = await client.listTimeSeries(request);   console.log('Found data points for the following instances:');   timeSeries.forEach(data => {     console.log(data.metric.labels.instance_name);   }); } readTimeSeriesFields();

use Google\Cloud\Monitoring\V3\Client\MetricServiceClient; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest\TimeSeriesView; use Google\Cloud\Monitoring\V3\TimeInterval; use Google\Protobuf\Timestamp;  /**  * Example:  * ```  * read_timeseries_fields($projectId);  * ```  *  * @param string $projectId Your project ID  */ function read_timeseries_fields(string $projectId, int $minutesAgo = 20): void {     $metrics = new MetricServiceClient([         'projectId' => $projectId,     ]);      $projectName = 'projects/' . $projectId;     $filter = 'metric.type="compute.googleapis.com/instance/cpu/utilization"';      $startTime = new Timestamp();     $startTime->setSeconds(time() - (60 * $minutesAgo));     $endTime = new Timestamp();     $endTime->setSeconds(time());      $interval = new TimeInterval();     $interval->setStartTime($startTime);     $interval->setEndTime($endTime);      $view = TimeSeriesView::HEADERS;     $listTimeSeriesRequest = (new ListTimeSeriesRequest())         ->setName($projectName)         ->setFilter($filter)         ->setInterval($interval)         ->setView($view);      $result = $metrics->listTimeSeries($listTimeSeriesRequest);      printf('Found data points for the following instances:' . PHP_EOL);     foreach ($result->iterateAllElements() as $timeSeries) {         printf($timeSeries->getMetric()->getLabels()['instance_name'] . PHP_EOL);     } }

from google.cloud import monitoring_v3  client = monitoring_v3.MetricServiceClient() project_name = f"projects/{project_id}" now = time.time() seconds = int(now) nanos = int((now - seconds) * 10**9) interval = monitoring_v3.TimeInterval(     {         "end_time": {"seconds": seconds, "nanos": nanos},         "start_time": {"seconds": (seconds - 1200), "nanos": nanos},     } ) results = client.list_time_series(     request={         "name": project_name,         "filter": 'metric.type = "compute.googleapis.com/instance/cpu/utilization"',         "interval": interval,         "view": monitoring_v3.ListTimeSeriesRequest.TimeSeriesView.HEADERS,     } ) for result in results:     print(result)

gem "google-cloud-monitoring" require "google/cloud/monitoring"  # Your Google Cloud Platform project ID # project_id = "YOUR_PROJECT_ID"  client = Google::Cloud::Monitoring.metric_service project_name = client.project_path project: project_id  interval = Google::Cloud::Monitoring::V3::TimeInterval.new now = Time.now interval.end_time = Google::Protobuf::Timestamp.new seconds: now.to_i,                                                     nanos:   now.nsec interval.start_time = Google::Protobuf::Timestamp.new seconds: now.to_i - 1200,                                                       nanos:   now.nsec filter = 'metric.type = "compute.googleapis.com/instance/cpu/utilization"' view = Google::Cloud::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::HEADERS  results = client.list_time_series name:     project_name,                                   filter:   filter,                                   interval: interval,                                   view:     view results.each do |result|   p result end

public static object ReadTimeSeriesData(string projectId,     string metricType = "compute.googleapis.com/instance/cpu/utilization") {     // Create client.     MetricServiceClient metricServiceClient = MetricServiceClient.Create();     // Initialize request argument(s).     string filter = $"metric.type=\"{metricType}\"";     ListTimeSeriesRequest request = new ListTimeSeriesRequest     {         ProjectName = new ProjectName(projectId),         Filter = filter,         Interval = new TimeInterval(),         View = ListTimeSeriesRequest.Types.TimeSeriesView.Full,     };     // Create timestamp for current time formatted in seconds.     long timeStamp = (long)(DateTime.UtcNow - s_unixEpoch).TotalSeconds;     Timestamp startTimeStamp = new Timestamp();     // Set startTime to limit results to the last 20 minutes.     startTimeStamp.Seconds = timeStamp - (60 * 20);     Timestamp endTimeStamp = new Timestamp();     // Set endTime to current time.     endTimeStamp.Seconds = timeStamp;     TimeInterval interval = new TimeInterval();     interval.StartTime = startTimeStamp;     interval.EndTime = endTimeStamp;     request.Interval = interval;     // Make the request.     PagedEnumerable<ListTimeSeriesResponse, TimeSeries> response =         metricServiceClient.ListTimeSeries(request);     // Iterate over all response items, lazily performing RPCs as required.     foreach (TimeSeries item in response)     {         Console.WriteLine(JObject.Parse($"{item}").ToString());     }     return 0; } 

 // readTimeSeriesValue reads the TimeSeries for the value specified by metric type in a time window from the last 20 minutes. func readTimeSeriesValue(projectID, metricType string) error { 	ctx := context.Background() 	c, err := monitoring.NewMetricClient(ctx) 	if err != nil { 		return err 	} 	defer c.Close() 	startTime := time.Now().UTC().Add(time.Minute * -20).Unix() 	endTime := time.Now().UTC().Unix()  	req := &monitoringpb.ListTimeSeriesRequest{ 		Name:   "projects/" + projectID, 		Filter: fmt.Sprintf("metric.type=\"%s\"", metricType), 		Interval: &monitoringpb.TimeInterval{ 			StartTime: &timestamp.Timestamp{Seconds: startTime}, 			EndTime:   &timestamp.Timestamp{Seconds: endTime}, 		}, 	} 	iter := c.ListTimeSeries(ctx, req)  	for { 		resp, err := iter.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return fmt.Errorf("could not read time series value, %w ", err) 		} 		log.Printf("%+v\n", resp) 	}  	return nil } 

String projectId = System.getProperty("projectId"); ProjectName name = ProjectName.of(projectId);  // Restrict time to last 20 minutes long startMillis = System.currentTimeMillis() - ((60 * 20) * 1000); TimeInterval interval =     TimeInterval.newBuilder()         .setStartTime(Timestamps.fromMillis(startMillis))         .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))         .build();  ListTimeSeriesRequest.Builder requestBuilder =     ListTimeSeriesRequest.newBuilder()         .setName(name.toString())         .setFilter(filter)         .setInterval(interval);  ListTimeSeriesRequest request = requestBuilder.build();  try (final MetricServiceClient client = MetricServiceClient.create();) {   ListTimeSeriesPagedResponse response = client.listTimeSeries(request);    System.out.println("Got timeseries: ");   for (TimeSeries ts : response.iterateAll()) {     System.out.println(ts);   } }

// Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.MetricServiceClient();  async function readTimeSeriesData() {   /**    * TODO(developer): Uncomment and edit the following lines of code.    */   // const projectId = 'YOUR_PROJECT_ID';   // const filter = 'metric.type="compute.googleapis.com/instance/cpu/utilization"';    const request = {     name: client.projectPath(projectId),     filter: filter,     interval: {       startTime: {         // Limit results to the last 20 minutes         seconds: Date.now() / 1000 - 60 * 20,       },       endTime: {         seconds: Date.now() / 1000,       },     },   };    // Writes time series data   const [timeSeries] = await client.listTimeSeries(request);   timeSeries.forEach(data => {     console.log(`${data.metric.labels.instance_name}:`);     data.points.forEach(point => {       console.log(JSON.stringify(point.value));     });   }); } readTimeSeriesData();

use Google\Cloud\Monitoring\V3\Client\MetricServiceClient; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest\TimeSeriesView; use Google\Cloud\Monitoring\V3\TimeInterval; use Google\Protobuf\Timestamp;  /**  * Example:  * ```  * read_timeseries_simple($projectId);  * ```  *  * @param string $projectId Your project ID  */ function read_timeseries_simple(string $projectId, int $minutesAgo = 20): void {     $metrics = new MetricServiceClient([         'projectId' => $projectId,     ]);      $projectName = 'projects/' . $projectId;     $filter = 'metric.type="compute.googleapis.com/instance/cpu/utilization"';      // Limit results to the last 20 minutes     $startTime = new Timestamp();     $startTime->setSeconds(time() - (60 * $minutesAgo));     $endTime = new Timestamp();     $endTime->setSeconds(time());      $interval = new TimeInterval();     $interval->setStartTime($startTime);     $interval->setEndTime($endTime);      $view = TimeSeriesView::FULL;     $listTimeSeriesRequest = (new ListTimeSeriesRequest())         ->setName($projectName)         ->setFilter($filter)         ->setInterval($interval)         ->setView($view);      $result = $metrics->listTimeSeries($listTimeSeriesRequest);      printf('CPU utilization:' . PHP_EOL);     foreach ($result->iterateAllElements() as $timeSeries) {         $instanceName = $timeSeries->getMetric()->getLabels()['instance_name'];         printf($instanceName . ':' . PHP_EOL);         foreach ($timeSeries->getPoints() as $point) {             printf('  ' . $point->getValue()->getDoubleValue() . PHP_EOL);         }     } }

from google.cloud import monitoring_v3  client = monitoring_v3.MetricServiceClient() project_name = f"projects/{project_id}"  now = time.time() seconds = int(now) nanos = int((now - seconds) * 10**9) interval = monitoring_v3.TimeInterval(     {         "end_time": {"seconds": seconds, "nanos": nanos},         "start_time": {"seconds": (seconds - 1200), "nanos": nanos},     } )  results = client.list_time_series(     request={         "name": project_name,         "filter": 'metric.type = "compute.googleapis.com/instance/cpu/utilization"',         "interval": interval,         "view": monitoring_v3.ListTimeSeriesRequest.TimeSeriesView.FULL,     } ) for result in results:     print(result)

gem "google-cloud-monitoring" require "google/cloud/monitoring"  # Your Google Cloud Platform project ID # project_id = "YOUR_PROJECT_ID"  client = Google::Cloud::Monitoring.metric_service project_name = client.project_path project: project_id  interval = Google::Cloud::Monitoring::V3::TimeInterval.new now = Time.now interval.end_time = Google::Protobuf::Timestamp.new seconds: now.to_i,                                                     nanos:   now.nsec interval.start_time = Google::Protobuf::Timestamp.new seconds: now.to_i - 1200,                                                       nanos:   now.nsec filter = 'metric.type = "compute.googleapis.com/instance/cpu/utilization"' view = Google::Cloud::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::FULL  results = client.list_time_series name:     project_name,                                   filter:   filter,                                   interval: interval,                                   view:     view results.each do |result|   p result end

public static object ReadTimeSeriesAggregate(string projectId,     string metricType = "compute.googleapis.com/instance/cpu/utilization") {     // Create client.     MetricServiceClient metricServiceClient = MetricServiceClient.Create();     // Initialize request argument(s).     string filter = $"metric.type=\"{metricType}\"";     ListTimeSeriesRequest request = new ListTimeSeriesRequest     {         ProjectName = new ProjectName(projectId),         Filter = filter,         Interval = new TimeInterval(),     };     // Create timestamp for current time formatted in seconds.     long timeStamp = (long)(DateTime.UtcNow - s_unixEpoch).TotalSeconds;     Timestamp startTimeStamp = new Timestamp();     // Set startTime to limit results to the last 20 minutes.     startTimeStamp.Seconds = timeStamp - (60 * 20);     Timestamp endTimeStamp = new Timestamp();     // Set endTime to current time.     endTimeStamp.Seconds = timeStamp;     TimeInterval interval = new TimeInterval();     interval.StartTime = startTimeStamp;     interval.EndTime = endTimeStamp;     request.Interval = interval;     // Aggregate results per matching instance     Aggregation aggregation = new Aggregation();     Duration alignmentPeriod = new Duration();     alignmentPeriod.Seconds = 600;     aggregation.AlignmentPeriod = alignmentPeriod;     aggregation.PerSeriesAligner = Aggregation.Types.Aligner.AlignMean;     // Add the aggregation to the request.     request.Aggregation = aggregation;     // Make the request.     PagedEnumerable<ListTimeSeriesResponse, TimeSeries> response =         metricServiceClient.ListTimeSeries(request);     // Iterate over all response items, lazily performing RPCs as required.     Console.WriteLine($"{projectId} CPU utilization:");     foreach (var item in response)     {         var points = item.Points;         var labels = item.Metric.Labels;         Console.WriteLine($"{labels.Values.FirstOrDefault()}");         if (points.Count > 0)         {             Console.WriteLine($"  Now: {points[0].Value.DoubleValue}");         }         if (points.Count > 1)         {             Console.WriteLine($"  10 min ago: {points[1].Value.DoubleValue}");         }     }     return 0; } 

import ( 	"context" 	"fmt" 	"io" 	"time"  	monitoring "cloud.google.com/go/monitoring/apiv3" 	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb" 	"github.com/golang/protobuf/ptypes/duration" 	"github.com/golang/protobuf/ptypes/timestamp" 	"google.golang.org/api/iterator" )  // readTimeSeriesAlign reads the last 20 minutes of the given metric and aligns // everything on 10 minute intervals. func readTimeSeriesAlign(w io.Writer, projectID string) error { 	ctx := context.Background() 	client, err := monitoring.NewMetricClient(ctx) 	if err != nil { 		return fmt.Errorf("NewMetricClient: %w", err) 	} 	defer client.Close() 	startTime := time.Now().UTC().Add(time.Minute * -20) 	endTime := time.Now().UTC() 	req := &monitoringpb.ListTimeSeriesRequest{ 		Name:   "projects/" + projectID, 		Filter: `metric.type="compute.googleapis.com/instance/cpu/utilization"`, 		Interval: &monitoringpb.TimeInterval{ 			StartTime: &timestamp.Timestamp{ 				Seconds: startTime.Unix(), 			}, 			EndTime: &timestamp.Timestamp{ 				Seconds: endTime.Unix(), 			}, 		}, 		Aggregation: &monitoringpb.Aggregation{ 			PerSeriesAligner: monitoringpb.Aggregation_ALIGN_MEAN, 			AlignmentPeriod: &duration.Duration{ 				Seconds: 600, 			}, 		}, 	} 	it := client.ListTimeSeries(ctx, req) 	for { 		resp, err := it.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return fmt.Errorf("could not read time series value: %w", err) 		} 		fmt.Fprintln(w, resp.GetMetric().GetLabels()["instance_name"]) 		fmt.Fprintf(w, "\tNow: %.4f\n", resp.GetPoints()[0].GetValue().GetDoubleValue()) 		if len(resp.GetPoints()) > 1 { 			fmt.Fprintf(w, "\t10 minutes ago: %.4f\n", resp.GetPoints()[1].GetValue().GetDoubleValue()) 		} 	} 	fmt.Fprintln(w, "Done") 	return nil } 

String projectId = System.getProperty("projectId"); ProjectName name = ProjectName.of(projectId);  // Restrict time to last 20 minutes long startMillis = System.currentTimeMillis() - ((60 * 20) * 1000); TimeInterval interval =     TimeInterval.newBuilder()         .setStartTime(Timestamps.fromMillis(startMillis))         .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))         .build();  Aggregation aggregation =     Aggregation.newBuilder()         .setAlignmentPeriod(Duration.newBuilder().setSeconds(600).build())         .setPerSeriesAligner(Aggregation.Aligner.ALIGN_MEAN)         .build();  ListTimeSeriesRequest.Builder requestBuilder =     ListTimeSeriesRequest.newBuilder()         .setName(name.toString())         .setFilter("metric.type=\"compute.googleapis.com/instance/cpu/utilization\"")         .setInterval(interval)         .setAggregation(aggregation);  ListTimeSeriesRequest request = requestBuilder.build();  try (final MetricServiceClient client = MetricServiceClient.create();) {   ListTimeSeriesPagedResponse response = client.listTimeSeries(request);    System.out.println("Got timeseries: ");   for (TimeSeries ts : response.iterateAll()) {     System.out.println(ts);   } }

// Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.MetricServiceClient();  async function readTimeSeriesAggregate() {   /**    * TODO(developer): Uncomment and edit the following lines of code.    */   // const projectId = 'YOUR_PROJECT_ID';    const request = {     name: client.projectPath(projectId),     filter: 'metric.type="compute.googleapis.com/instance/cpu/utilization"',     interval: {       startTime: {         // Limit results to the last 20 minutes         seconds: Date.now() / 1000 - 60 * 20,       },       endTime: {         seconds: Date.now() / 1000,       },     },     // Aggregate results per matching instance     aggregation: {       alignmentPeriod: {         seconds: 600,       },       perSeriesAligner: 'ALIGN_MEAN',     },   };    // Writes time series data   const [timeSeries] = await client.listTimeSeries(request);   console.log('CPU utilization:');   timeSeries.forEach(data => {     console.log(data.metric.labels.instance_name);     console.log(`  Now: ${data.points[0].value.doubleValue}`);     if (data.points.length > 1) {       console.log(`  10 min ago: ${data.points[1].value.doubleValue}`);     }     console.log('=====');   }); } readTimeSeriesAggregate();

use Google\Cloud\Monitoring\V3\Aggregation; use Google\Cloud\Monitoring\V3\Aggregation\Aligner; use Google\Cloud\Monitoring\V3\Client\MetricServiceClient; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest\TimeSeriesView; use Google\Cloud\Monitoring\V3\TimeInterval; use Google\Protobuf\Duration; use Google\Protobuf\Timestamp;  /**  * Example:  * ```  * read_timeseries_align($projectId);  * ```  *  * @param string $projectId Your project ID  */ function read_timeseries_align(string $projectId, int $minutesAgo = 20): void {     $metrics = new MetricServiceClient([         'projectId' => $projectId,     ]);      $projectName = 'projects/' . $projectId;     $filter = 'metric.type="compute.googleapis.com/instance/cpu/utilization"';      $startTime = new Timestamp();     $startTime->setSeconds(time() - (60 * $minutesAgo));     $endTime = new Timestamp();     $endTime->setSeconds(time());      $interval = new TimeInterval();     $interval->setStartTime($startTime);     $interval->setEndTime($endTime);      $alignmentPeriod = new Duration();     $alignmentPeriod->setSeconds(600);     $aggregation = new Aggregation();     $aggregation->setAlignmentPeriod($alignmentPeriod);     $aggregation->setPerSeriesAligner(Aligner::ALIGN_MEAN);      $view = TimeSeriesView::FULL;     $listTimeSeriesRequest = (new ListTimeSeriesRequest())         ->setName($projectName)         ->setFilter($filter)         ->setInterval($interval)         ->setView($view)         ->setAggregation($aggregation);      $result = $metrics->listTimeSeries($listTimeSeriesRequest);      printf('CPU utilization:' . PHP_EOL);     foreach ($result->iterateAllElements() as $timeSeries) {         printf($timeSeries->getMetric()->getLabels()['instance_name'] . PHP_EOL);         printf('  Now: ');         printf($timeSeries->getPoints()[0]->getValue()->getDoubleValue() . PHP_EOL);         if (count($timeSeries->getPoints()) > 1) {             printf('  10 minutes ago: ');             printf($timeSeries->getPoints()[1]->getValue()->getDoubleValue() . PHP_EOL);         }     } }

from google.cloud import monitoring_v3  client = monitoring_v3.MetricServiceClient() project_name = f"projects/{project_id}"  now = time.time() seconds = int(now) nanos = int((now - seconds) * 10**9) interval = monitoring_v3.TimeInterval(     {         "end_time": {"seconds": seconds, "nanos": nanos},         "start_time": {"seconds": (seconds - 3600), "nanos": nanos},     } ) aggregation = monitoring_v3.Aggregation(     {         "alignment_period": {"seconds": 1200},  # 20 minutes         "per_series_aligner": monitoring_v3.Aggregation.Aligner.ALIGN_MEAN,     } )  results = client.list_time_series(     request={         "name": project_name,         "filter": 'metric.type = "compute.googleapis.com/instance/cpu/utilization"',         "interval": interval,         "view": monitoring_v3.ListTimeSeriesRequest.TimeSeriesView.FULL,         "aggregation": aggregation,     } ) for result in results:     print(result)

gem "google-cloud-monitoring" require "google/cloud/monitoring"  # Your Google Cloud Platform project ID # project_id = "YOUR_PROJECT_ID"  client = Google::Cloud::Monitoring.metric_service project_name = client.project_path project: project_id  interval = Google::Cloud::Monitoring::V3::TimeInterval.new now = Time.now interval.end_time = Google::Protobuf::Timestamp.new seconds: now.to_i,                                                     nanos:   now.nsec interval.start_time = Google::Protobuf::Timestamp.new seconds: now.to_i - 1200,                                                       nanos:   now.nsec filter = 'metric.type = "compute.googleapis.com/instance/cpu/utilization"' view = Google::Cloud::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::FULL aggregation = Google::Cloud::Monitoring::V3::Aggregation.new(   alignment_period:   { seconds: 1200 },   per_series_aligner: Google::Cloud::Monitoring::V3::Aggregation::Aligner::ALIGN_MEAN )  results = client.list_time_series name:        project_name,                                   filter:      filter,                                   interval:    interval,                                   view:        view,                                   aggregation: aggregation results.each do |result|   p result end 

public static object ReadTimeSeriesReduce(string projectId,     string metricType = "compute.googleapis.com/instance/cpu/utilization") {     // Create client.     MetricServiceClient metricServiceClient = MetricServiceClient.Create();     // Initialize request argument(s).     string filter = $"metric.type=\"{metricType}\"";     ListTimeSeriesRequest request = new ListTimeSeriesRequest     {         ProjectName = new ProjectName(projectId),         Filter = filter,         Interval = new TimeInterval(),     };     // Create timestamp for current time formatted in seconds.     long timeStamp = (long)(DateTime.UtcNow - s_unixEpoch).TotalSeconds;     Timestamp startTimeStamp = new Timestamp();     // Set startTime to limit results to the last 20 minutes.     startTimeStamp.Seconds = timeStamp - (60 * 20);     Timestamp endTimeStamp = new Timestamp();     // Set endTime to current time.     endTimeStamp.Seconds = timeStamp;     TimeInterval interval = new TimeInterval();     interval.StartTime = startTimeStamp;     interval.EndTime = endTimeStamp;     request.Interval = interval;     // Aggregate results per matching instance.     Aggregation aggregation = new Aggregation();     Duration alignmentPeriod = new Duration();     alignmentPeriod.Seconds = 600;     aggregation.AlignmentPeriod = alignmentPeriod;     aggregation.CrossSeriesReducer = Aggregation.Types.Reducer.ReduceMean;     aggregation.PerSeriesAligner = Aggregation.Types.Aligner.AlignMean;     // Add the aggregation to the request.     request.Aggregation = aggregation;     // Make the request.     PagedEnumerable<ListTimeSeriesResponse, TimeSeries> response =         metricServiceClient.ListTimeSeries(request);     // Iterate over all response items, lazily performing RPCs as required.     Console.WriteLine("CPU utilization:");     foreach (var item in response)     {         var points = item.Points;         Console.WriteLine("Average CPU utilization across all GCE instances:");         Console.WriteLine($"  Last 10 min: {points[0].Value.DoubleValue}");         Console.WriteLine($"  Last 10-20 min ago: {points[1].Value.DoubleValue}");     }     return 0; } 

import ( 	"context" 	"fmt" 	"io" 	"time"  	monitoring "cloud.google.com/go/monitoring/apiv3" 	"cloud.google.com/go/monitoring/apiv3/v2/monitoringpb" 	"github.com/golang/protobuf/ptypes/duration" 	"github.com/golang/protobuf/ptypes/timestamp" 	"google.golang.org/api/iterator" )  // readTimeSeriesReduce reads the last 20 minutes of the given metric, aligns // everything on 10 minute intervals, and combines values from different // instances. func readTimeSeriesReduce(w io.Writer, projectID string) error { 	ctx := context.Background() 	client, err := monitoring.NewMetricClient(ctx) 	if err != nil { 		return fmt.Errorf("NewMetricClient: %w", err) 	} 	defer client.Close() 	startTime := time.Now().UTC().Add(time.Minute * -20) 	endTime := time.Now().UTC() 	req := &monitoringpb.ListTimeSeriesRequest{ 		Name:   "projects/" + projectID, 		Filter: `metric.type="compute.googleapis.com/instance/cpu/utilization"`, 		Interval: &monitoringpb.TimeInterval{ 			StartTime: &timestamp.Timestamp{ 				Seconds: startTime.Unix(), 			}, 			EndTime: &timestamp.Timestamp{ 				Seconds: endTime.Unix(), 			}, 		}, 		Aggregation: &monitoringpb.Aggregation{ 			CrossSeriesReducer: monitoringpb.Aggregation_REDUCE_MEAN, 			PerSeriesAligner:   monitoringpb.Aggregation_ALIGN_MEAN, 			AlignmentPeriod: &duration.Duration{ 				Seconds: 600, 			}, 		}, 	} 	it := client.ListTimeSeries(ctx, req) 	for { 		resp, err := it.Next() 		if err == iterator.Done { 			break 		} 		if err != nil { 			return fmt.Errorf("could not read time series value: %w", err) 		} 		fmt.Fprintln(w, "Average CPU utilization across all GCE instances:") 		fmt.Fprintf(w, "\tNow: %.4f\n", resp.GetPoints()[0].GetValue().GetDoubleValue()) 		if len(resp.GetPoints()) > 1 { 			fmt.Fprintf(w, "\t10 minutes ago: %.4f\n", resp.GetPoints()[1].GetValue().GetDoubleValue()) 		} 	} 	fmt.Fprintln(w, "Done") 	return nil } 

String projectId = System.getProperty("projectId"); ProjectName name = ProjectName.of(projectId);  // Restrict time to last 20 minutes long startMillis = System.currentTimeMillis() - ((60 * 20) * 1000); TimeInterval interval =     TimeInterval.newBuilder()         .setStartTime(Timestamps.fromMillis(startMillis))         .setEndTime(Timestamps.fromMillis(System.currentTimeMillis()))         .build();  Aggregation aggregation =     Aggregation.newBuilder()         .setAlignmentPeriod(Duration.newBuilder().setSeconds(600).build())         .setPerSeriesAligner(Aggregation.Aligner.ALIGN_MEAN)         .setCrossSeriesReducer(Aggregation.Reducer.REDUCE_MEAN)         .build();  ListTimeSeriesRequest.Builder requestBuilder =     ListTimeSeriesRequest.newBuilder()         .setName(name.toString())         .setFilter("metric.type=\"compute.googleapis.com/instance/cpu/utilization\"")         .setInterval(interval)         .setAggregation(aggregation);  ListTimeSeriesRequest request = requestBuilder.build();  try (final MetricServiceClient client = MetricServiceClient.create();) {   ListTimeSeriesPagedResponse response = client.listTimeSeries(request);    System.out.println("Got timeseries: ");   for (TimeSeries ts : response.iterateAll()) {     System.out.println(ts);   } }

// Imports the Google Cloud client library const monitoring = require('@google-cloud/monitoring');  // Creates a client const client = new monitoring.MetricServiceClient();  async function readTimeSeriesReduce() {   /**    * TODO(developer): Uncomment and edit the following lines of code.    */   // const projectId = 'YOUR_PROJECT_ID';    const request = {     name: client.projectPath(projectId),     filter: 'metric.type="compute.googleapis.com/instance/cpu/utilization"',     interval: {       startTime: {         // Limit results to the last 20 minutes         seconds: Date.now() / 1000 - 60 * 20,       },       endTime: {         seconds: Date.now() / 1000,       },     },     // Aggregate results per matching instance     aggregation: {       alignmentPeriod: {         seconds: 600,       },       crossSeriesReducer: 'REDUCE_MEAN',       perSeriesAligner: 'ALIGN_MEAN',     },   };    // Writes time series data   const [result] = await client.listTimeSeries(request);   if (result.length === 0) {     console.log('No data');     return;   }   const reductions = result[0].points;    console.log('Average CPU utilization across all GCE instances:');   console.log(`  Last 10 min: ${reductions[0].value.doubleValue}`);   console.log(`  10-20 min ago: ${reductions[0].value.doubleValue}`); } readTimeSeriesReduce();

use Google\Cloud\Monitoring\V3\Aggregation; use Google\Cloud\Monitoring\V3\Client\MetricServiceClient; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest; use Google\Cloud\Monitoring\V3\ListTimeSeriesRequest\TimeSeriesView; use Google\Cloud\Monitoring\V3\TimeInterval; use Google\Protobuf\Duration; use Google\Protobuf\Timestamp;  /**  * Example:  * ```  * read_timeseries_reduce($projectId);  * ```  *  * @param string $projectId Your project ID  */ function read_timeseries_reduce(string $projectId, int $minutesAgo = 20): void {     $metrics = new MetricServiceClient([         'projectId' => $projectId,     ]);      $projectName = 'projects/' . $projectId;     $filter = 'metric.type="compute.googleapis.com/instance/cpu/utilization"';      $startTime = new Timestamp();     $startTime->setSeconds(time() - (60 * $minutesAgo));     $endTime = new Timestamp();     $endTime->setSeconds(time());      $interval = new TimeInterval();     $interval->setStartTime($startTime);     $interval->setEndTime($endTime);      $alignmentPeriod = new Duration();     $alignmentPeriod->setSeconds(600);     $aggregation = new Aggregation();     $aggregation->setAlignmentPeriod($alignmentPeriod);     $aggregation->setCrossSeriesReducer(Aggregation\Reducer::REDUCE_MEAN);     $aggregation->setPerSeriesAligner(Aggregation\Aligner::ALIGN_MEAN);      $view = TimeSeriesView::FULL;     $listTimeSeriesRequest = (new ListTimeSeriesRequest())         ->setName($projectName)         ->setFilter($filter)         ->setInterval($interval)         ->setView($view)         ->setAggregation($aggregation);      $result = $metrics->listTimeSeries($listTimeSeriesRequest);      printf('Average CPU utilization across all GCE instances:' . PHP_EOL);     if ($timeSeries = $result->iterateAllElements()->current()) {         $reductions = $timeSeries->getPoints();         printf('  Last 10 minutes: ');         printf($reductions[0]->getValue()->getDoubleValue() . PHP_EOL);         if (count($reductions) > 1) {             printf('  10-20 minutes ago: ');             printf($reductions[1]->getValue()->getDoubleValue() . PHP_EOL);         }     } }

from google.cloud import monitoring_v3  client = monitoring_v3.MetricServiceClient() project_name = f"projects/{project_id}"  now = time.time() seconds = int(now) nanos = int((now - seconds) * 10**9) interval = monitoring_v3.TimeInterval(     {         "end_time": {"seconds": seconds, "nanos": nanos},         "start_time": {"seconds": (seconds - 3600), "nanos": nanos},     } ) aggregation = monitoring_v3.Aggregation(     {         "alignment_period": {"seconds": 1200},  # 20 minutes         "per_series_aligner": monitoring_v3.Aggregation.Aligner.ALIGN_MEAN,         "cross_series_reducer": monitoring_v3.Aggregation.Reducer.REDUCE_MEAN,         "group_by_fields": ["resource.zone"],     } )  results = client.list_time_series(     request={         "name": project_name,         "filter": 'metric.type = "compute.googleapis.com/instance/cpu/utilization"',         "interval": interval,         "view": monitoring_v3.ListTimeSeriesRequest.TimeSeriesView.FULL,         "aggregation": aggregation,     } ) for result in results:     print(result)

gem "google-cloud-monitoring" require "google/cloud/monitoring"  # Your Google Cloud Platform project ID # project_id = "YOUR_PROJECT_ID"  client = Google::Cloud::Monitoring.metric_service project_name = client.project_path project: project_id  interval = Google::Cloud::Monitoring::V3::TimeInterval.new now = Time.now interval.end_time = Google::Protobuf::Timestamp.new seconds: now.to_i,                                                     nanos:   now.nsec interval.start_time = Google::Protobuf::Timestamp.new seconds: now.to_i - 1200,                                                       nanos:   now.nsec filter = 'metric.type = "compute.googleapis.com/instance/cpu/utilization"' view = Google::Cloud::Monitoring::V3::ListTimeSeriesRequest::TimeSeriesView::FULL aggregation = Google::Cloud::Monitoring::V3::Aggregation.new(   alignment_period:     { seconds: 1200 },   per_series_aligner:   Google::Cloud::Monitoring::V3::Aggregation::Aligner::ALIGN_MEAN,   cross_series_reducer: Google::Cloud::Monitoring::V3::Aggregation::Reducer::REDUCE_MEAN,   group_by_fields:      ["resource.zone"] )  results = client.list_time_series name:        project_name,                                   filter:      filter,                                   interval:    interval,                                   view:        view,                                   aggregation: aggregation results.each do |result|   p result end