Finish new Monitoring samples.

monitoring/README.md

@@ -58,10 +58,20 @@ Options:
   --projectId, -p                                                                                               [string]
 
 Examples:
+  node metrics.js create
   node metrics.js list
   node metrics.js get logging.googleapis.com/log_entry_count
+  node metrics.js delete
+  custom.googleapis.com/stores/daily_sales
   node metrics.js list-resources
   node metrics.js get-resource cloudsql_database
+  node metrics.js write
+  node metrics.js read
+  'metric.type="compute.googleapis.com/instance/cpu/utilizatio
+  n"'
+  node metrics.js read-fields
+  node metrics.js read-aggregate
+  node metrics.js read-reduce
 
 For more information, see https://cloud.google.com/monitoring/docs
 ```

monitoring/metrics.js

@@ -295,7 +295,7 @@ function readTimeSeriesFields (projectId) {
 
       console.log('Found data points for the following instances:');
       timeSeries.forEach((data) => {
-        console.log(`${data.metric.labels.instance_name}`);
+        console.log(data.metric.labels.instance_name);
       });
     });
   // [END monitoring_read_timeseries_fields]
@@ -340,7 +340,7 @@ function readTimeSeriesAggregate (projectId) {
 
       console.log('CPU utilization:');
       timeSeries.forEach((data) => {
-        console.log(`${data.metric.labels.instance_name}`);
+        console.log(data.metric.labels.instance_name);
         console.log(`  Now: ${data.points[0].value.doubleValue}`);
         console.log(`  10 min ago: ${data.points[1].value.doubleValue}`);
       });
@@ -530,10 +530,17 @@ const cli = require(`yargs`)
       type: 'string'
     }
   })
+  .example(`node $0 create`)
   .example(`node $0 list`)
   .example(`node $0 get logging.googleapis.com/log_entry_count`)
+  .example(`node $0 delete custom.googleapis.com/stores/daily_sales`)
   .example(`node $0 list-resources`)
   .example(`node $0 get-resource cloudsql_database`)
+  .example(`node $0 write`)
+  .example(`node $0 read 'metric.type="compute.googleapis.com/instance/cpu/utilization"'`)
+  .example(`node $0 read-fields`)
+  .example(`node $0 read-aggregate`)
+  .example(`node $0 read-reduce`)
   .wrap(120)
   .recommendCommands()
   .epilogue(`For more information, see https://cloud.google.com/monitoring/docs`);

monitoring/package.json

@@ -5,7 +5,7 @@
   "license": "Apache Version 2.0",
   "author": "Google Inc.",
   "scripts": {
-    "test": "cd ..; npm run st -- --verbose monitoring/system-test/metrics.test.js"
+    "test": "cd ..; npm run st -- --verbose monitoring/system-test/*.test.js"
   },
   "dependencies": {
     "@google-cloud/monitoring": "0.1.4",

monitoring/quickstart.js

@@ -25,35 +25,47 @@ const projectId = 'YOUR_PROJECT_ID';
 // Instantiates a client
 const client = Monitoring.v3().metricServiceClient();
 
-const request = {
-  name: client.projectPath(projectId),
-  filter: 'metric.type="compute.googleapis.com/instance/cpu/utilization"',
+// Prepares an individual data point
+const dataPoint = {
   interval: {
-    startTime: {
-      // Limit results to the last 10 minutes
-      seconds: (Date.now() / 1000) - (60 * 10)
-    },
     endTime: {
       seconds: Date.now() / 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: 'custom.googleapis.com/stores/daily_sales',
+        labels: {
+          store_id: 'Pittsburgh'
+        }
+      },
+      resource: {
+        type: 'global',
+        labels: {
+          project_id: projectId
+        }
+      },
+      points: [
+        dataPoint
+      ]
+    }
+  ]
+};
+
 // Writes time series data
-client.listTimeSeries(request)
+client.createTimeSeries(request)
   .then((results) => {
-    const timeSeries = results[0];
-
-    console.log('Found CPU utilization data for the following instances:');
-    timeSeries.forEach((computeInstance) => {
-      const instanceName = computeInstance.metric.labels.instance_name;
-      console.log(`  ${instanceName}:`);
-
-      computeInstance.points.forEach((point) => {
-        const startTime = new Date(point.interval.startTime.seconds * 1000);
-        const value = point.value.doubleValue;
-        console.log(`    ${startTime.toISOString()} - ${value}`);
-      });
-    });
+    console.log(`Done writing time series data.`);
   });
 // [END monitoring_quickstart]

monitoring/system-test/metrics.test.js

@@ -17,12 +17,14 @@
 
 require(`../../system-test/_setup`);
 
+const client = require(`@google-cloud/monitoring`).v3().metricServiceClient();
 const path = require(`path`);
 
 const cmd = `node metrics.js`;
 const cwd = path.join(__dirname, `..`);
 const customMetricId = `custom.googleapis.com/stores/daily_sales`;
 const computeMetricId = `compute.googleapis.com/instance/cpu/utilization`;
+const filter = `metric.type="${computeMetricId}"`;
 const projectId = process.env.GCLOUD_PROJECT;
 const resourceId = `cloudsql_database`;
 
@@ -50,6 +52,11 @@ test.serial(`should get a metric descriptor`, async (t) => {
   }).start();
 });
 
+test.serial(`should write time series data`, async (t) => {
+  const output = await runAsync(`${cmd} write`, cwd);
+  t.true(output.includes(`Done writing time series data.`));
+});
+
 test.serial(`should delete a metric descriptor`, async (t) => {
   const output = await runAsync(`${cmd} delete ${customMetricId}`, cwd);
   t.true(output.includes(`Deleted ${customMetricId}`));
@@ -64,3 +71,109 @@ test(`should get a monitored resource descriptor`, async (t) => {
   const output = await runAsync(`${cmd} get-resource ${resourceId}`, cwd);
   t.true(output.includes(`Type: ${resourceId}`));
 });
+
+test(`should read time series data`, async (t) => {
+  const [timeSeries] = await client.listTimeSeries({
+    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
+      }
+    }
+  });
+  const output = await runAsync(`${cmd} read '${filter}'`, cwd);
+  timeSeries.forEach((data) => {
+    t.true(output.includes(`${data.metric.labels.instance_name}:`));
+    data.points.forEach((point) => {
+      t.true(output.includes(JSON.stringify(point.value)));
+    });
+  });
+});
+
+test(`should read time series data fields`, async (t) => {
+  const [timeSeries] = await client.listTimeSeries({
+    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
+      }
+    },
+    // Don't return time series data, instead just return information about
+    // the metrics that match the filter
+    view: `HEADERS`
+  });
+  const output = await runAsync(`${cmd} read-fields`, cwd);
+  t.true(output.includes(`Found data points for the following instances:`));
+  timeSeries.forEach((data) => {
+    t.true(output.includes(data.metric.labels.instance_name));
+  });
+});
+
+test(`should read time series data aggregated`, async (t) => {
+  const [timeSeries] = await client.listTimeSeries({
+    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
+      }
+    },
+    // Aggregate results per matching instance
+    aggregation: {
+      alignmentPeriod: {
+        seconds: 600
+      },
+      perSeriesAligner: `ALIGN_MEAN`
+    }
+  });
+  const output = await runAsync(`${cmd} read-aggregate`, cwd);
+  t.true(output.includes(`CPU utilization:`));
+  timeSeries.forEach((data) => {
+    t.true(output.includes(data.metric.labels.instance_name));
+    t.true(output.includes(`  Now: ${data.points[0].value.doubleValue}`));
+    t.true(output.includes(`  10 min ago: ${data.points[1].value.doubleValue}`));
+  });
+});
+
+test(`should read time series data reduced`, async (t) => {
+  const [timeSeries] = await client.listTimeSeries({
+    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
+      }
+    },
+    // Aggregate results per matching instance
+    aggregation: {
+      alignmentPeriod: {
+        seconds: 600
+      },
+      crossSeriesReducer: `REDUCE_MEAN`,
+      perSeriesAligner: `ALIGN_MEAN`
+    }
+  });
+  const reductions = timeSeries[0].points;
+  const output = await runAsync(`${cmd} read-reduce`, cwd);
+  t.true(output.includes(`Average CPU utilization across all GCE instances:`));
+  t.true(output.includes(`  Last 10 min: ${reductions[0].value.doubleValue}`));
+  t.true(output.includes(`  10-20 min ago: ${reductions[0].value.doubleValue}`));
+});

monitoring/system-test/quickstart.test.js

@@ -26,27 +26,23 @@ test.afterEach.always(restoreConsole);
 test.cb(`should list time series`, (t) => {
   const clientMock = {
     projectPath: (projectId) => client.projectPath(projectId),
-    listTimeSeries: (_request) => {
+    createTimeSeries: (_request) => {
       _request.name = client.projectPath(process.env.GCLOUD_PROJECT);
+      _request.timeSeries[0].resource.labels.project_id = process.env.GCLOUD_PROJECT;
 
-      return client.listTimeSeries(_request)
-        .then(([timeSeries]) => {
-          t.true(Array.isArray(timeSeries));
-
+      return client.createTimeSeries(_request)
+        .then((result) => {
           setTimeout(() => {
             try {
-              let numCalls = 1 + timeSeries.length;
-              timeSeries.forEach((computeInstance) => {
-                numCalls += computeInstance.points.length;
-              });
-              t.is(console.log.callCount, numCalls);
+              t.is(console.log.callCount, 1);
+              t.deepEqual(console.log.getCall(0).args, [`Done writing time series data.`]);
               t.end();
             } catch (err) {
               t.end(err);
             }
           }, 200);
 
-          return [timeSeries];
+          return result;
         });
     }
   };