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 make_time_series(metric_name, point, kind):
gcp_series = monitoring_v3.TimeSeries()
gcp_series.metric.type = f'{METRIC_BASE}/{metric_name}'
gcp_series.metric_kind = kind
Metrics.add_resource(gcp_series)
point.interval.end_time = datetime.datetime.now()
gcp_series.points.append(point)
return gcp_series
def _extract_header(time_series):
"""Return a copy of time_series with the points removed."""
return monitoring_v3.TimeSeries(
metric=time_series.metric,
resource=time_series.resource,
metric_kind=time_series.metric_kind,
value_type=time_series.value_type,
)
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 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 make_time_series(metric_name, point, kind):
gcp_series = monitoring_v3.TimeSeries()
# TimeSeries are uniquely identified by metric x resource
gcp_series.metric.type = f'{METRIC_BASE}/{metric_name}'
gcp_series.metric_kind = kind
gcp_series.resource.type = RESOURCE_TYPE
gcp_series.resource.labels['cluster_name'] = CLUSTER_NAME
gcp_series.resource.labels['namespace_name'] = NAMESPACE_NAME
gcp_series.resource.labels['location'] = GCP_ZONE
gcp_series.resource.labels['container_name'] = CONTAINER_NAME
gcp_series.resource.labels['pod_name'] = POD_NAME
point.interval.end_time = datetime.datetime.now()
gcp_series.points.append(point)
return gcp_series
def generate_query_results():
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})
for metric_labels, resource_labels, value in zip(METRIC_LABELS,
RESOURCE_LABELS, VALUES):
yield monitoring_v3.TimeSeries(
metric=metric_pb2.Metric(type=METRIC_TYPE, labels=metric_labels),
resource=monitored_resource_pb2.MonitoredResource(
type=RESOURCE_TYPE, labels=resource_labels),
metric_kind=METRIC_KIND,
value_type=VALUE_TYPE,
points=[P(t, value) for t in TIMESTAMPS],
)
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 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
