def run_quickstart(project=""):
# [START monitoring_quickstart]
from google.cloud import monitoring_v3
import time
client = monitoring_v3.MetricServiceClient()
# project = 'my-project' # TODO: Update to your project ID.
project_name = f"projects/{project}"
series = monitoring_v3.TimeSeries()
series.metric.type = "custom.googleapis.com/my_metric"
series.resource.type = "gce_instance"
series.resource.labels["instance_id"] = "1234567890123456789"
series.resource.labels["zone"] = "us-central1-f"
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
interval = monitoring_v3.TimeInterval(
{"end_time": {
"seconds": seconds,
"nanos": nanos
}})
point = monitoring_v3.Point({
"interval": interval,
"value": {
"double_value": 3.14
}
})
series.points = [point]
client.create_time_series(request={
"name": project_name,
"time_series": [series]
})
print("Successfully wrote time series.")
def write_time_series(project_id):
# [START monitoring_write_timeseries]
client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"
series = monitoring_v3.TimeSeries()
series.metric.type = "custom.googleapis.com/my_metric" + str(uuid.uuid4())
series.resource.type = "gce_instance"
series.resource.labels["instance_id"] = "1234567890123456789"
series.resource.labels["zone"] = "us-central1-f"
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
interval = monitoring_v3.TimeInterval(
{"end_time": {
"seconds": seconds,
"nanos": nanos
}})
point = monitoring_v3.Point({
"interval": interval,
"value": {
"double_value": 3.14
}
})
series.points = [point]
client.create_time_series(name=project_name, time_series=[series])
def send_metric(sales_item, sales_num, report_time):
client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{PROJECT_ID}"
series = monitoring_v3.TimeSeries()
series.metric.type = f"custom.googleapis.com/{CUSTOM_METRIC_NAME}"
# Available resource types: https://cloud.google.com/monitoring/api/resources
series.resource.type = "global"
series.resource.labels["project_id"] = PROJECT_ID
# If needed, add more labels for filtering and grouping
series.metric.labels["item"] = sales_item
epoch = report_time.timestamp()
seconds = int(epoch)
interval = monitoring_v3.TimeInterval(
{"end_time": {
"seconds": seconds,
"nanos": 0
}})
point = monitoring_v3.Point({
"interval": interval,
"value": {
"int64_value": sales_num
}
})
series.points = [point]
client.create_time_series(request={
"name": project_name,
"time_series": [series]
})
print("Successfully wrote time series.")
def gauge_int_timeseries(resource_type, resource_labels, metric_type,
metric_labels, value):
"""Build GAUGE INT timeseries object."""
series = monitoring_v3.TimeSeries()
series.metric.type = metric_type
series.metric.labels.update(metric_labels)
series.resource.type = resource_type
series.resource.labels.update(resource_labels)
series.metric_kind = 'GAUGE'
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
interval = monitoring_v3.TimeInterval(
{'end_time': {
'seconds': seconds,
'nanos': nanos
}})
point = monitoring_v3.Point({
'interval':
interval,
'value':
monitoring_v3.TypedValue(int64_value=value)
})
series.points = [point]
return series
def P(timestamp, value):
interval = monitoring_v3.TimeInterval()
interval.start_time = datetime_helpers.from_rfc3339(timestamp).replace(
tzinfo=None)
interval.end_time = datetime_helpers.from_rfc3339(timestamp).replace(
tzinfo=None)
return monitoring_v3.Point(interval=interval,
value={"double_value": value})
def record_metric(project_name, metric):
"""Create TS entry for captured metric"""
global logger
global now
global monitoring_client
series = monitoring_v3.TimeSeries()
series.resource.type = "global"
series.metric.type = f"custom.googleapis.com/{metric['Benchmark']}"
# Required to maintain uniqueness of each permutation
series.metric.labels["Run"] = metric["Run"]
series.metric.labels["Iteration"] = metric["Iteration"]
# Populate dynamic labels, GCP limit is 10 labels per descriptor
for key in list(metric.keys()):
if key not in ["Benchmark", "Run", "Iteration", "Score"]:
series.metric.labels[key] = metric[key]
if len(series.metric.labels) > GCP_LABEL_LIMIT:
logger.warn(
f"Exiting metric label loop, limit of {GCP_LABEL_LIMIT} labels."
)
break # Break out, we have hit limit on labels
seconds = int(now)
nanos = int((now - seconds) * 10 ** 9)
interval = monitoring_v3.TimeInterval(
{"end_time": {"seconds": seconds, "nanos": nanos}}
)
point = monitoring_v3.Point(
{"interval": interval, "value": {"double_value": float(metric["Score"])}}
)
series.points = [point]
logger.info(
f"Publishing {series.resource.type}/{series.metric.type}: {metric['Score']}"
)
try:
monitoring_client.create_time_series(name=project_name, time_series=[series])
except InternalServerError:
logger.error(
f"Failed to publish metric {series.metric.type}, this may be because the metric descriptor has been recently created. Will retry on the next run."
)
def report_metric(value, type, instance_id, zone, project_id):
series = monitoring_v3.types.TimeSeries()
series.metric.type = 'custom.googleapis.com/{type}'.format(type=type)
series.resource.type = 'gce_instance'
series.resource.labels['instance_id'] = instance_id
series.resource.labels['zone'] = zone
series.resource.labels['project_id'] = project_id
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10 ** 9)
interval = monitoring_v3.TimeInterval(
{"end_time": {"seconds": seconds, "nanos": nanos}}
)
point = monitoring_v3.Point({"interval": interval, "value": {"double_value": 3.14}})
series.points = [point]
client.create_time_series(name=project_name, time_series=[series])
def write_data_to_metric(config, monitored_project_id, value, metric_name,
network_name):
'''
Writes data to Cloud Monitoring custom metrics.
Parameters:
config (dict): The dict containing config like clients and limits
monitored_project_id: ID of the project where the resource lives (will be added as a label)
value (int): Value for the data point of the metric.
metric_name (string): Name of the metric
network_name (string): Name of the network (will be added as a label)
Returns:
usage (int): Current usage for that network.
limit (int): Current usage for that network.
'''
client = monitoring_v3.MetricServiceClient()
series = monitoring_v3.TimeSeries()
series.metric.type = f"custom.googleapis.com/{metric_name}"
series.resource.type = "global"
series.metric.labels["network_name"] = network_name
series.metric.labels["project"] = monitored_project_id
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
interval = monitoring_v3.TimeInterval(
{"end_time": {
"seconds": seconds,
"nanos": nanos
}})
point = monitoring_v3.Point({
"interval": interval,
"value": {
"double_value": value
}
})
series.points = [point]
# TODO: sometimes this cashes with 'DeadlineExceeded: 504 Deadline expired before operation could complete' error
# Implement exponential backoff retries?
try:
client.create_time_series(name=config["monitoring_project_link"],
time_series=[series])
except Exception as e:
print(e)
def write_time_series(project_id,requested_pets):
client = monitoring_v3.MetricServiceClient()
project_name = f"projects/{project_id}"
series = monitoring_v3.TimeSeries()
series.metric.type = "custom.googleapis.com/" + CUSTOM_METRIC_NAME_PREFIX + PROJECT_ID
series.resource.type = "gae_instance"
series.resource.labels["instance_id"] = os.environ["GAE_INSTANCE"]
series.resource.labels["location"] = "us-east1"
series.resource.labels["module_id"] = os.environ["GAE_APPLICATION"]
series.resource.labels["version_id"] = os.environ["GAE_VERSION"]
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10 ** 9)
interval = monitoring_v3.TimeInterval(
{"end_time": {"seconds": seconds, "nanos": nanos}}
)
point = monitoring_v3.Point({"interval": interval, "value": {"int64_value": requested_pets}})
series.points = [point]
client.create_time_series(name=project_name, time_series=[series])
def _convert_series(self, metric, ts):
"""Convert an OC timeseries to a SD series."""
series = monitoring_v3.TimeSeries()
series.metric.type = self.get_metric_type(metric.descriptor)
for lk, lv in self.options.default_monitoring_labels.items():
series.metric.labels[lk.key] = lv.value
for key, val in zip(metric.descriptor.label_keys, ts.label_values):
if val.value is not None:
safe_key = sanitize_label(key.key)
series.metric.labels[safe_key] = val.value
set_monitored_resource(series, self.options.resource)
for point in ts.points:
sd_point = monitoring_v3.Point()
# this just modifies points, no return
self._convert_point(metric, ts, point, sd_point)
series.points.append(sd_point)
return series
def build_series(self, prefix, name, labels, details):
s = monitoring_v3.types.TimeSeries()
s.metric.type = f'custom.googleapis.com/{self.app_name}/{prefix}/{name}'
s.resource.type = 'generic_task'
s.resource.labels.update(labels)
# setup time for submissions
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10 ** 9)
interval = monitoring_v3.TimeInterval(
{"end_time": {"seconds": seconds, "nanos": nanos}}
)
# create the data point
p = monitoring_v3.Point({
'interval': interval,
'value': {details['kind']: details['value']},
})
s.points = [p]
return s
def report_metric(value, metric_type, resource_values):
"""Create time series for report.
Args:
value: (int) Report metric value.
metric_type: (str) Metric type
resource_values: (dict) Contains resources information
"""
client = resource_values.get('client')
project_id = resource_values.get('project_id')
instance_id = resource_values.get('instance_id')
zone = resource_values.get('zone')
project_name = client.common_project_path(project_id)
# TimeSeries definition.
series = monitoring_v3.types.TimeSeries()
series.metric.type = 'custom.googleapis.com/{type}'.format(
type=metric_type)
series.resource.type = 'gce_instance'
series.resource.labels['instance_id'] = instance_id
series.resource.labels['zone'] = zone
series.resource.labels['project_id'] = project_id
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
interval = monitoring_v3.TimeInterval(
{"end_time": {
"seconds": seconds,
"nanos": nanos
}})
point = monitoring_v3.Point({
"interval": interval,
"value": {
"int64_value": value
}
})
series.points = [point]
client.create_time_series(name=project_name, time_series=[series])
def report_metric(value, t, instance_id, zone, project_id):
series = monitoring_v3.types.TimeSeries()
series.metric.type = 'custom.googleapis.com/{type}'.format(type=t)
series.resource.type = 'gce_instance'
series.resource.labels['instance_id'] = instance_id
series.resource.labels['zone'] = zone
series.resource.labels['project_id'] = project_id
now = time.time()
seconds = int(now)
nanos = int((now - seconds) * 10**9)
interval = monitoring_v3.TimeInterval(
{'end_time': {
'seconds': seconds,
'nanos': nanos
}})
point = monitoring_v3.Point()
point.value.int64_value = value
point.interval = interval
series.points.append(point)
client.create_time_series(request={
'name': project_name,
'time_series': [series]
})
def test_iteration(self):
T0 = datetime.datetime(2016, 4, 6, 22, 5, 0)
T1 = datetime.datetime(2016, 4, 6, 22, 10, 0)
INTERVAL1 = self._make_interval(TS1, TS0)
INTERVAL2 = self._make_interval(TS2, TS1)
VALUE1 = 60 # seconds
VALUE2 = 60.001 # seconds
# Currently cannot create from a list of dict for repeated fields due to
# https://github.com/googleapis/proto-plus-python/issues/135
POINT1 = monitoring_v3.Point({
"interval": INTERVAL2,
"value": {
"double_value": VALUE1
}
})
POINT2 = monitoring_v3.Point({
"interval": INTERVAL1,
"value": {
"double_value": VALUE1
}
})
POINT3 = monitoring_v3.Point({
"interval": INTERVAL2,
"value": {
"double_value": VALUE2
}
})
POINT4 = monitoring_v3.Point({
"interval": INTERVAL1,
"value": {
"double_value": VALUE2
}
})
SERIES1 = monitoring_v3.TimeSeries({
"metric": {
"type": METRIC_TYPE,
"labels": METRIC_LABELS
},
"resource": {
"type": RESOURCE_TYPE,
"labels": RESOURCE_LABELS
},
"metric_kind": METRIC_KIND,
"value_type": VALUE_TYPE,
"points": [POINT1, POINT2],
})
SERIES2 = monitoring_v3.TimeSeries({
"metric": {
"type": METRIC_TYPE,
"labels": METRIC_LABELS2
},
"resource": {
"type": RESOURCE_TYPE,
"labels": RESOURCE_LABELS2
},
"metric_kind": METRIC_KIND,
"value_type": VALUE_TYPE,
"points": [POINT3, POINT4],
})
RESPONSE = {"time_series": [SERIES1, SERIES2], "next_page_token": ""}
channel = ChannelStub(responses=[RESPONSE])
client = self._create_client(channel)
query = self._make_one(client, PROJECT, METRIC_TYPE)
query = query.select_interval(start_time=T0, end_time=T1)
response = list(query)
self.assertEqual(len(response), 2)
series1, series2 = response
self.assertEqual(series1.metric.labels, METRIC_LABELS)
self.assertEqual(series2.metric.labels, METRIC_LABELS2)
self.assertEqual(series1.resource.labels, RESOURCE_LABELS)
self.assertEqual(series2.resource.labels, RESOURCE_LABELS2)
self.assertEqual([p.value.double_value for p in series1.points],
[VALUE1, VALUE1])
self.assertEqual([p.value.double_value for p in series2.points],
[VALUE2, VALUE2])
self.assertEqual([p.interval for p in series1.points],
[INTERVAL2, INTERVAL1])
self.assertEqual([p.interval for p in series2.points],
[INTERVAL2, INTERVAL1])
expected_request = monitoring_v3.ListTimeSeriesRequest(
name="projects/" + PROJECT,
filter='metric.type = "{type}"'.format(type=METRIC_TYPE),
interval=self._make_interval(T1, T0),
view=monitoring_v3.ListTimeSeriesRequest.TimeSeriesView.FULL,
)
request = channel.requests[0][1]
self.assertEqual(request, expected_request)
def _fixed_list_time_series(self) -> Iterable[TimeSeries]:
def _make_interval(end_time, start_time):
interval = monitoring_v3.TimeInterval(end_time=end_time,
start_time=start_time)
return interval
INTERVAL1 = _make_interval(TS1, TS0)
INTERVAL2 = _make_interval(TS2, TS1)
VALUE1 = 60 # seconds
VALUE2 = 42 # seconds
# Currently cannot create from a list of dict for repeated fields due to
# https://github.com/googleapis/proto-plus-python/issues/135
POINT1 = monitoring_v3.Point({
"interval": INTERVAL2,
"value": {
"double_value": VALUE1
}
})
POINT2 = monitoring_v3.Point({
"interval": INTERVAL1,
"value": {
"double_value": VALUE1
}
})
POINT3 = monitoring_v3.Point({
"interval": INTERVAL2,
"value": {
"double_value": VALUE2
}
})
POINT4 = monitoring_v3.Point({
"interval": INTERVAL1,
"value": {
"double_value": VALUE2
}
})
SERIES1 = monitoring_v3.TimeSeries({
"metric": {
"type": METRIC_TYPE,
"labels": METRIC_LABELS
},
"resource": {
"type": RESOURCE_TYPE,
"labels": RESOURCE_LABELS
},
"metric_kind": METRIC_KIND,
"value_type": VALUE_TYPE,
"points": [POINT1, POINT2],
})
SERIES2 = monitoring_v3.TimeSeries({
"metric": {
"type": METRIC_TYPE,
"labels": METRIC_LABELS2
},
"resource": {
"type": RESOURCE_TYPE,
"labels": RESOURCE_LABELS2
},
"metric_kind": METRIC_KIND,
"value_type": VALUE_TYPE,
"points": [POINT3, POINT4],
})
yield SERIES1
yield SERIES2