diff --git a/gcloud/monitoring/__init__.py b/gcloud/monitoring/__init__.py new file mode 100644 index 000000000000..b1e9db9f6536 --- /dev/null +++ b/gcloud/monitoring/__init__.py @@ -0,0 +1,15 @@ +# Copyright 2016 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +"""Google Cloud Monitoring API wrapper.""" diff --git a/gcloud/monitoring/agent_translation_service_api.py b/gcloud/monitoring/agent_translation_service_api.py new file mode 100644 index 000000000000..db10461a4082 --- /dev/null +++ b/gcloud/monitoring/agent_translation_service_api.py @@ -0,0 +1,143 @@ +# Copyright 2016 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# EDITING INSTRUCTIONS +# This file was generated from the file +# https://github.com/google/googleapis/blob/master/google/monitoring/v3/agent_service.proto, +# and updates to that file get reflected here through a refresh process. +# For the short term, the refresh process will only be runnable by Google engineers. +# Manual additions are allowed because the refresh process performs +# a 3-way merge in order to preserve those manual additions. In order to not +# break the refresh process, only certain types of modifications are +# allowed. +# +# Allowed modifications: +# 1. New methods (these should be added to the end of the class) +# +# Happy editing! + +from google.gax import PageDescriptor +from google.gax import api_callable +from google.gax import config +from google.gax.path_template import PathTemplate +from google.monitoring.v3 import agent_service_pb2 +from google.api import monitored_resource_pb2 +from google.monitoring.v3 import agent_pb2 + + +class AgentTranslationServiceApi(object): + """ + The AgentTranslation API allows `collectd`-based agents to + write time series data to Cloud Monitoring. + See [google.monitoring.v3.MetricService.CreateTimeSeries] instead. + """ + + # The default address of the logging service. + _SERVICE_ADDRESS = 'monitoring.googleapis.com' + + # The default port of the logging service. + _DEFAULT_SERVICE_PORT = 443 + + # The scopes needed to make gRPC calls to all of the methods defined in + # this service + _ALL_SCOPES = ( + 'https://www.googleapis.com/auth/monitoring', + 'https://www.googleapis.com/auth/monitoring.write', + 'https://www.googleapis.com/auth/monitoring.read', + 'https://www.googleapis.com/auth/cloud-platform', + ) + + + + class Templates(object): + """PathTemplates for resources used by AgentTranslationServiceApi.""" + PROJECT = PathTemplate.from_string( + 'projects/{project}') + + def __init__( + self, + service_path=_SERVICE_ADDRESS, + port=_DEFAULT_SERVICE_PORT, + channel=None, + ssl_creds=None, + scopes=_ALL_SCOPES, + is_idempotent_retrying=True, + max_attempts=3, + timeout=30): + self.defaults = api_callable.ApiCallableDefaults( + timeout=timeout, + max_attempts=max_attempts, + is_idempotent_retrying=is_idempotent_retrying) + + self.stub = config.create_stub( + agent_service_pb2.beta_create_AgentTranslationService_stub, + service_path, + port, + ssl_creds=ssl_creds, + channel=channel, + scopes=scopes) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + + def close(self): + del self.stub + + # Service calls + def create_collectd_time_series( + self, + name='', + resource=None, + collectd_version='', + collectd_payloads=None, + **kwargs): + """ + Creates a new time series with the given data points. This method + is only for use in `collectd`-related code, including the Google + Monitoring Agent. See + [google.monitoring.v3.MetricService.CreateTimeSeries] instead. + + :type name: string + :type resource: monitored_resource_pb2.MonitoredResource + :type collectd_version: string + :type collectd_payloads: list of agent_pb2.CollectdPayload + """ + if resource is None: + resource = monitored_resource_pb2.MonitoredResource() + if collectd_payloads is None: + collectd_payloads = [] + create_collectd_time_series_request = agent_service_pb2.CreateCollectdTimeSeriesRequest( + name=name, + resource=resource, + collectd_version=collectd_version, + collectd_payloads=collectd_payloads, + **kwargs) + return self.create_collectd_time_series_callable()(create_collectd_time_series_request) + + def create_collectd_time_series_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.CreateCollectdTimeSeries, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + # ======== + # Manually-added methods: add custom (non-generated) methods after this point. + # ======== \ No newline at end of file diff --git a/gcloud/monitoring/group_service_api.py b/gcloud/monitoring/group_service_api.py new file mode 100644 index 000000000000..8c83a68f9896 --- /dev/null +++ b/gcloud/monitoring/group_service_api.py @@ -0,0 +1,342 @@ +# Copyright 2016 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# EDITING INSTRUCTIONS +# This file was generated from the file +# https://github.com/google/googleapis/blob/master/google/monitoring/v3/group_service.proto, +# and updates to that file get reflected here through a refresh process. +# For the short term, the refresh process will only be runnable by Google engineers. +# Manual additions are allowed because the refresh process performs +# a 3-way merge in order to preserve those manual additions. In order to not +# break the refresh process, only certain types of modifications are +# allowed. +# +# Allowed modifications: +# 1. New methods (these should be added to the end of the class) +# +# Happy editing! + +from google.gax import PageDescriptor +from google.gax import api_callable +from google.gax import config +from google.gax.path_template import PathTemplate +from google.monitoring.v3 import group_service_pb2 +from google.api import monitored_resource_pb2 +from google.monitoring.v3 import common_pb2 +from google.monitoring.v3 import group_pb2 + + +class GroupServiceApi(object): + """ + The Group API lets you inspect and manage your + [groups](google.monitoring.v3.Group). + + A group is a named filter that is used to identify + a collection of monitored resources. Groups are typically used to + mirror the physical and/or logical topology of the environment. + Because group membership is computed dynamically, monitored + resources that are started in the future are automatically placed + in matching groups. By using a group to name monitored resources in, + for example, an alert policy, the target of that alert policy is + updated automatically as monitored resources are added and removed + from the infrastructure. + """ + + # The default address of the logging service. + _SERVICE_ADDRESS = 'monitoring.googleapis.com' + + # The default port of the logging service. + _DEFAULT_SERVICE_PORT = 443 + + # The scopes needed to make gRPC calls to all of the methods defined in + # this service + _ALL_SCOPES = ( + 'https://www.googleapis.com/auth/monitoring', + 'https://www.googleapis.com/auth/monitoring.write', + 'https://www.googleapis.com/auth/monitoring.read', + 'https://www.googleapis.com/auth/cloud-platform', + ) + + _LIST_GROUPS_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'group', + ) + _LIST_GROUPS_FOR_RESOURCE_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'group', + ) + _LIST_GROUP_MEMBERS_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'members', + ) + + class Templates(object): + """PathTemplates for resources used by GroupServiceApi.""" + PROJECT = PathTemplate.from_string( + 'projects/{project}') + GROUP = PathTemplate.from_string( + 'projects/{project}/groups/{group}') + + def __init__( + self, + service_path=_SERVICE_ADDRESS, + port=_DEFAULT_SERVICE_PORT, + channel=None, + ssl_creds=None, + scopes=_ALL_SCOPES, + is_idempotent_retrying=True, + max_attempts=3, + timeout=30): + self.defaults = api_callable.ApiCallableDefaults( + timeout=timeout, + max_attempts=max_attempts, + is_idempotent_retrying=is_idempotent_retrying) + + self.stub = config.create_stub( + group_service_pb2.beta_create_GroupService_stub, + service_path, + port, + ssl_creds=ssl_creds, + channel=channel, + scopes=scopes) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + + def close(self): + del self.stub + + # Service calls + def list_groups( + self, + name='', + children_of_group='', + ancestors_of_group='', + descendants_of_group='', + **kwargs): + """ + Lists the existing groups. + + :type name: string + :type children_of_group: string + :type ancestors_of_group: string + :type descendants_of_group: string + """ + + list_groups_request = group_service_pb2.ListGroupsRequest( + name=name, + children_of_group=children_of_group, + ancestors_of_group=ancestors_of_group, + descendants_of_group=descendants_of_group, + **kwargs) + return self.list_groups_callable()(list_groups_request) + + def list_groups_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_GROUPS_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListGroups, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def list_groups_for_resource( + self, + name='', + monitored_resource=None, + **kwargs): + """ + Lists the groups containing a specific monitored resource. + + :type name: string + :type monitored_resource: monitored_resource_pb2.MonitoredResource + """ + if monitored_resource is None: + monitored_resource = monitored_resource_pb2.MonitoredResource() + list_groups_for_resource_request = group_service_pb2.ListGroupsForResourceRequest( + name=name, + monitored_resource=monitored_resource, + **kwargs) + return self.list_groups_for_resource_callable()(list_groups_for_resource_request) + + def list_groups_for_resource_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_GROUPS_FOR_RESOURCE_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListGroupsForResource, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def get_group( + self, + name='', + **kwargs): + """ + Gets a single group. + + :type name: string + """ + + get_group_request = group_service_pb2.GetGroupRequest( + name=name, + **kwargs) + return self.get_group_callable()(get_group_request) + + def get_group_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.GetGroup, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def create_group( + self, + name='', + group=None, + validate_only=False, + **kwargs): + """ + Creates a new group. + + :type name: string + :type group: group_pb2.Group + :type validate_only: bool + """ + if group is None: + group = group_pb2.Group() + create_group_request = group_service_pb2.CreateGroupRequest( + name=name, + group=group, + validate_only=validate_only, + **kwargs) + return self.create_group_callable()(create_group_request) + + def create_group_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.CreateGroup, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def update_group( + self, + group=None, + validate_only=False, + **kwargs): + """ + Updates an existing group. + You can change any group attributes except `name`. + + :type group: group_pb2.Group + :type validate_only: bool + """ + if group is None: + group = group_pb2.Group() + update_group_request = group_service_pb2.UpdateGroupRequest( + group=group, + validate_only=validate_only, + **kwargs) + return self.update_group_callable()(update_group_request) + + def update_group_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.UpdateGroup, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def delete_group( + self, + name='', + **kwargs): + """ + Deletes an existing group. + + :type name: string + """ + + delete_group_request = group_service_pb2.DeleteGroupRequest( + name=name, + **kwargs) + return self.delete_group_callable()(delete_group_request) + + def delete_group_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.DeleteGroup, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def list_group_members( + self, + name='', + filter_='', + interval=None, + **kwargs): + """ + Lists the monitored resources that are members of a group. + + :type name: string + :type filter: string + :type interval: common_pb2.TimeInterval + """ + if interval is None: + interval = common_pb2.TimeInterval() + list_group_members_request = group_service_pb2.ListGroupMembersRequest( + name=name, + filter=filter_, + interval=interval, + **kwargs) + return self.list_group_members_callable()(list_group_members_request) + + def list_group_members_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_GROUP_MEMBERS_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListGroupMembers, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + # ======== + # Manually-added methods: add custom (non-generated) methods after this point. + # ======== \ No newline at end of file diff --git a/gcloud/monitoring/metric_service_api.py b/gcloud/monitoring/metric_service_api.py new file mode 100644 index 000000000000..35a6fb5fcb77 --- /dev/null +++ b/gcloud/monitoring/metric_service_api.py @@ -0,0 +1,458 @@ +# Copyright 2016 Google Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# EDITING INSTRUCTIONS +# This file was generated from the file +# https://github.com/google/googleapis/blob/master/google/monitoring/v3/metric_service.proto, +# and updates to that file get reflected here through a refresh process. +# For the short term, the refresh process will only be runnable by Google engineers. +# Manual additions are allowed because the refresh process performs +# a 3-way merge in order to preserve those manual additions. In order to not +# break the refresh process, only certain types of modifications are +# allowed. +# +# Allowed modifications: +# 1. New methods (these should be added to the end of the class) +# +# Happy editing! + +from google.gax import PageDescriptor +from google.gax import api_callable +from google.gax import config +from google.gax.path_template import PathTemplate +from google.monitoring.v3 import metric_service_pb2 +from google.api import metric_pb2 as api_metric_pb2 +from google.api import monitored_resource_pb2 +from google.monitoring.v3 import common_pb2 +from google.monitoring.v3 import metric_pb2 as v3_metric_pb2 + + +class MetricServiceApi(object): + """ + Manages metric descriptors, monitored resource descriptors, and + time series data. + """ + + # The default address of the logging service. + _SERVICE_ADDRESS = 'monitoring.googleapis.com' + + # The default port of the logging service. + _DEFAULT_SERVICE_PORT = 443 + + # The scopes needed to make gRPC calls to all of the methods defined in + # this service + _ALL_SCOPES = ( + 'https://www.googleapis.com/auth/monitoring', + 'https://www.googleapis.com/auth/monitoring.write', + 'https://www.googleapis.com/auth/monitoring.read', + 'https://www.googleapis.com/auth/cloud-platform', + ) + + _LIST_MONITORED_RESOURCE_DESCRIPTORS_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'resource_descriptors', + ) + _LIST_METRIC_DESCRIPTORS_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'metric_descriptors', + ) + _LIST_TIME_SERIES_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'time_series', + ) + _LIST_MONITORED_RESOURCES_FOR_METRIC_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'monitored_resources', + ) + _LIST_METRICS_DESCRIPTOR = PageDescriptor( + 'page_token', + 'next_page_token', + 'metrics', + ) + + class Templates(object): + """PathTemplates for resources used by MetricServiceApi.""" + PROJECT = PathTemplate.from_string( + 'projects/{project}') + MONITORED_RESOURCE_DESCRIPTOR = PathTemplate.from_string( + 'projects/{project}/monitoredResourceDescriptors/{monitoredResourceDescriptor}') + METRIC_DESCRIPTOR = PathTemplate.from_string( + 'projects/{project}/metricDescriptors/{metricDescriptor}') + + def __init__( + self, + service_path=_SERVICE_ADDRESS, + port=_DEFAULT_SERVICE_PORT, + channel=None, + ssl_creds=None, + scopes=_ALL_SCOPES, + is_idempotent_retrying=True, + max_attempts=3, + timeout=30): + self.defaults = api_callable.ApiCallableDefaults( + timeout=timeout, + max_attempts=max_attempts, + is_idempotent_retrying=is_idempotent_retrying) + + self.stub = config.create_stub( + metric_service_pb2.beta_create_MetricService_stub, + service_path, + port, + ssl_creds=ssl_creds, + channel=channel, + scopes=scopes) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + + def close(self): + del self.stub + + # Service calls + def list_monitored_resource_descriptors( + self, + name='', + filter_='', + **kwargs): + """ + Lists monitored resource descriptors that match a filter. + + :type name: string + :type filter: string + """ + + list_monitored_resource_descriptors_request = metric_service_pb2.ListMonitoredResourceDescriptorsRequest( + name=name, + filter=filter_, + **kwargs) + return self.list_monitored_resource_descriptors_callable()(list_monitored_resource_descriptors_request) + + def list_monitored_resource_descriptors_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_MONITORED_RESOURCE_DESCRIPTORS_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListMonitoredResourceDescriptors, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def get_monitored_resource_descriptor( + self, + name='', + **kwargs): + """ + Gets a single monitored resource descriptor. + + :type name: string + """ + + get_monitored_resource_descriptor_request = metric_service_pb2.GetMonitoredResourceDescriptorRequest( + name=name, + **kwargs) + return self.get_monitored_resource_descriptor_callable()(get_monitored_resource_descriptor_request) + + def get_monitored_resource_descriptor_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.GetMonitoredResourceDescriptor, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def list_metric_descriptors( + self, + name='', + filter_='', + **kwargs): + """ + Lists metric descriptors that match a filter. + + :type name: string + :type filter: string + """ + + list_metric_descriptors_request = metric_service_pb2.ListMetricDescriptorsRequest( + name=name, + filter=filter_, + **kwargs) + return self.list_metric_descriptors_callable()(list_metric_descriptors_request) + + def list_metric_descriptors_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_METRIC_DESCRIPTORS_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListMetricDescriptors, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def get_metric_descriptor( + self, + name='', + **kwargs): + """ + Gets a single metric descriptor. + + :type name: string + """ + + get_metric_descriptor_request = metric_service_pb2.GetMetricDescriptorRequest( + name=name, + **kwargs) + return self.get_metric_descriptor_callable()(get_metric_descriptor_request) + + def get_metric_descriptor_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.GetMetricDescriptor, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def create_metric_descriptor( + self, + name='', + metric_descriptor=None, + **kwargs): + """ + Creates a new metric descriptor. + User-created metric descriptors define + [custom metrics](/monitoring/custom-metrics). + + :type name: string + :type metric_descriptor: api_metric_pb2.MetricDescriptor + """ + if metric_descriptor is None: + metric_descriptor = api_metric_pb2.MetricDescriptor() + create_metric_descriptor_request = metric_service_pb2.CreateMetricDescriptorRequest( + name=name, + metric_descriptor=metric_descriptor, + **kwargs) + return self.create_metric_descriptor_callable()(create_metric_descriptor_request) + + def create_metric_descriptor_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.CreateMetricDescriptor, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def delete_metric_descriptor( + self, + name='', + **kwargs): + """ + Deletes a metric descriptor. Only user-created + [custom metrics](/monitoring/custom-metrics) can be deleted. + + :type name: string + """ + + delete_metric_descriptor_request = metric_service_pb2.DeleteMetricDescriptorRequest( + name=name, + **kwargs) + return self.delete_metric_descriptor_callable()(delete_metric_descriptor_request) + + def delete_metric_descriptor_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.DeleteMetricDescriptor, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def list_time_series( + self, + name='', + filter_='', + interval=None, + aggregation=None, + order_by='', + view=None, + **kwargs): + """ + Lists the time series that match a filter. + + :type name: string + :type filter: string + :type interval: common_pb2.TimeInterval + :type aggregation: common_pb2.Aggregation + :type order_by: string + :type view: enum metric_service_pb2.ListTimeSeriesRequest.TimeSeriesView + """ + if interval is None: + interval = common_pb2.TimeInterval() + if aggregation is None: + aggregation = common_pb2.Aggregation() + if view is None: + view = metric_service_pb2.ListTimeSeriesRequest.FULL + list_time_series_request = metric_service_pb2.ListTimeSeriesRequest( + name=name, + filter=filter_, + interval=interval, + aggregation=aggregation, + order_by=order_by, + view=view, + **kwargs) + return self.list_time_series_callable()(list_time_series_request) + + def list_time_series_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_TIME_SERIES_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListTimeSeries, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def create_time_series( + self, + name='', + time_series=None, + **kwargs): + """ + Creates or adds data to one or more time series. + You must check the response to see if any of the requests failed. + + :type name: string + :type time_series: list of v3_metric_pb2.TimeSeries + """ + if time_series is None: + time_series = [] + create_time_series_request = metric_service_pb2.CreateTimeSeriesRequest( + name=name, + time_series=time_series, + **kwargs) + return self.create_time_series_callable()(create_time_series_request) + + def create_time_series_callable( + self, + is_retrying=None, + max_attempts=None): + return api_callable.idempotent_callable( + self.stub.CreateTimeSeries, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def list_monitored_resources_for_metric( + self, + name='', + metric_name='', + interval=None, + view=None, + **kwargs): + """ + Lists the monitored resources against which data is written for a specific + metric name. + + :type name: string + :type metric_name: string + :type interval: common_pb2.TimeInterval + :type view: enum metric_service_pb2.ListMonitoredResourcesForMetricRequest.MonitoredResourceView + """ + if interval is None: + interval = common_pb2.TimeInterval() + if view is None: + view = metric_service_pb2.ListMonitoredResourcesForMetricRequest.FULL + list_monitored_resources_for_metric_request = metric_service_pb2.ListMonitoredResourcesForMetricRequest( + name=name, + metric_name=metric_name, + interval=interval, + view=view, + **kwargs) + return self.list_monitored_resources_for_metric_callable()(list_monitored_resources_for_metric_request) + + def list_monitored_resources_for_metric_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_MONITORED_RESOURCES_FOR_METRIC_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListMonitoredResourcesForMetric, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + def list_metrics( + self, + name='', + interval=None, + monitored_resource=None, + view=None, + **kwargs): + """ + Lists the metrics for which there exists data. Optionally restricts the + metrics to a partially specified monitored resource. + + :type name: string + :type interval: common_pb2.TimeInterval + :type monitored_resource: monitored_resource_pb2.MonitoredResource + :type view: enum metric_service_pb2.ListMetricsRequest.MetricView + """ + if interval is None: + interval = common_pb2.TimeInterval() + if monitored_resource is None: + monitored_resource = monitored_resource_pb2.MonitoredResource() + if view is None: + view = metric_service_pb2.ListMetricsRequest.FULL + list_metrics_request = metric_service_pb2.ListMetricsRequest( + name=name, + interval=interval, + monitored_resource=monitored_resource, + view=view, + **kwargs) + return self.list_metrics_callable()(list_metrics_request) + + def list_metrics_callable( + self, + is_retrying=None, + max_attempts=None, + page_streaming=_LIST_METRICS_DESCRIPTOR): + return api_callable.idempotent_callable( + self.stub.ListMetrics, + page_streaming=page_streaming, + is_retrying=is_retrying, + max_attempts=max_attempts, + defaults=self.defaults) + + # ======== + # Manually-added methods: add custom (non-generated) methods after this point. + # ======== \ No newline at end of file diff --git a/setup.py b/setup.py index bb620df8c515..e7941a600a5b 100644 --- a/setup.py +++ b/setup.py @@ -15,6 +15,7 @@ 'google-gax', 'googleapis-common-protos', 'grpc-google-logging-v2', + 'grpc-google-monitoring-v3', 'httplib2 >= 0.9.1', 'oauth2client >= 1.4.6', 'protobuf >= 3.0.0b2',