def test_list_alert_policies(self): client = monitoring_v3.AlertPolicyServiceClient() name_inside = client.project_path(PROJECT_INSIDE) delayed_inside = lambda: client.list_alert_policies(name_inside) name_outside = client.project_path(PROJECT_OUTSIDE) delayed_outside = lambda: client.list_alert_policies(name_outside) self._do_test(delayed_inside, delayed_outside)
def test_update_alert_policy(self): # Setup Expected Response name = "name3373707" display_name = "displayName1615086568" expected_response = {"name": name, "display_name": display_name} expected_response = alert_pb2.AlertPolicy(**expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup Request alert_policy = {} response = client.update_alert_policy(alert_policy) assert expected_response == response assert len(channel.requests) == 1 expected_request = alert_service_pb2.UpdateAlertPolicyRequest( alert_policy=alert_policy ) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_create_alert_policy(self): # Setup Expected Response name_2 = 'name2-1052831874' display_name = 'displayName1615086568' expected_response = {'name': name_2, 'display_name': display_name} expected_response = alert_pb2.AlertPolicy(**expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch('google.api_core.grpc_helpers.create_channel') with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup Request name = client.project_path('[PROJECT]') alert_policy = {} response = client.create_alert_policy(name, alert_policy) assert expected_response == response assert len(channel.requests) == 1 expected_request = alert_service_pb2.CreateAlertPolicyRequest( name=name, alert_policy=alert_policy) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_list_alert_policies(self): # Setup Expected Response next_page_token = "" alert_policies_element = {} alert_policies = [alert_policies_element] expected_response = { "next_page_token": next_page_token, "alert_policies": alert_policies, } expected_response = alert_service_pb2.ListAlertPoliciesResponse( **expected_response ) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup Request name = client.project_path("[PROJECT]") paged_list_response = client.list_alert_policies(name) resources = list(paged_list_response) assert len(resources) == 1 assert expected_response.alert_policies[0] == resources[0] assert len(channel.requests) == 1 expected_request = alert_service_pb2.ListAlertPoliciesRequest(name=name) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_get_alert_policy(self): client = monitoring_v3.AlertPolicyServiceClient() name_inside = client.alert_policy_path(PROJECT_INSIDE, "mock_alert_policy") delayed_inside = lambda: client.get_alert_policy(name_inside) name_outside = client.alert_policy_path(PROJECT_OUTSIDE, "mock_alert_policy") delayed_outside = lambda: client.get_alert_policy(name_outside) TestVPCServiceControlV3._do_test(delayed_inside, delayed_outside)
def test_create_alert_policy(self): client = monitoring_v3.AlertPolicyServiceClient() name_inside = client.project_path(PROJECT_INSIDE) delayed_inside = lambda: client.create_alert_policy(name_inside, {}) name_outside = client.project_path(PROJECT_OUTSIDE) delayed_outside = lambda: client.create_alert_policy(name_outside, {}) TestVPCServiceControlV3._do_test(delayed_inside, delayed_outside)
def test_list_alert_policies(self): # Setup Expected Response next_page_token = '' alert_policies_element = {} alert_policies = [alert_policies_element] expected_response = { 'next_page_token': next_page_token, 'alert_policies': alert_policies } expected_response = alert_service_pb2.ListAlertPoliciesResponse( **expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) client = monitoring_v3.AlertPolicyServiceClient(channel=channel) # Setup Request name = client.project_path('[PROJECT]') paged_list_response = client.list_alert_policies(name) resources = list(paged_list_response) assert len(resources) == 1 assert expected_response.alert_policies[0] == resources[0] assert len(channel.requests) == 1 expected_request = alert_service_pb2.ListAlertPoliciesRequest( name=name) actual_request = channel.requests[0][1] assert expected_request == actual_request
def enable_alert_policies(project_name, enable, filter_=None): """Enable or disable alert policies in a project. Arguments: project_name (str) enable (bool): Enable or disable the policies. filter_ (str, optional): Only enable/disable alert policies that match this filter_. See https://cloud.google.com/monitoring/api/v3/sorting-and-filtering """ client = monitoring_v3.AlertPolicyServiceClient() policies = client.list_alert_policies( request={"name": project_name, "filter": filter_} ) for policy in policies: if bool(enable) == policy.enabled: print( "Policy", policy.name, "is already", "enabled" if policy.enabled else "disabled", ) else: policy.enabled = bool(enable) mask = field_mask.FieldMask() mask.paths.append("enabled") client.update_alert_policy(alert_policy=policy, update_mask=mask) print("Enabled" if enable else "Disabled", policy.name)
def structured_backup( folder=backup_folder(), project_name=project_name(), permissions=0o755): folder = os.path.join(folder, datetime.datetime.now().strftime("%Y%m%d%H%M")) alert_client = monitoring_v3.AlertPolicyServiceClient() channel_client = monitoring_v3.NotificationChannelServiceClient() if os.path.exists(folder): raise FileExistsError os.mkdir(folder) os.mkdir(os.path.join(folder, "policies"), permissions) os.mkdir(os.path.join(folder, "channels"), permissions) for policy in alert_client.list_alert_policies(project_name): json.dump(policy, open( os.path.join(folder, "policies", __sanitize_filename(policy.display_name)), 'wt'), cls=ProtoEncoder, indent=2) for channel in channel_client.list_notification_channels(project_name): json.dump(channel, open( os.path.join(folder, "channels", __sanitize_filename(channel.display_name)), 'wt'), cls=ProtoEncoder, indent=2) print('Backed up alert policies and notification channels to {}.'.format( folder))
def list_alert_policies(project_name): client = monitoring_v3.AlertPolicyServiceClient() policies = client.list_alert_policies(name=project_name) print( tabulate.tabulate( [(policy.name, policy.display_name) for policy in policies], ("name", "display_name"), ))
def test_list_alert_policies_exception(self): channel = ChannelStub(responses=[CustomException()]) client = monitoring_v3.AlertPolicyServiceClient(channel=channel) # Setup request name = client.project_path('[PROJECT]') paged_list_response = client.list_alert_policies(name) with pytest.raises(CustomException): list(paged_list_response)
def test_update_alert_policy_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) client = monitoring_v3.AlertPolicyServiceClient(channel=channel) # Setup request alert_policy = {} with pytest.raises(CustomException): client.update_alert_policy(alert_policy)
def test_delete_alert_policy_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) client = monitoring_v3.AlertPolicyServiceClient(channel=channel) # Setup request name = client.alert_policy_path('[PROJECT]', '[ALERT_POLICY]') with pytest.raises(CustomException): client.delete_alert_policy(name)
def testUptimeCheckAlertingPolicy(self): """ Test that an alerting policy was created. """ client = monitoring_v3.AlertPolicyServiceClient() policies = client.list_alert_policies(project_name) found_uptime_alert = False for policy in policies: if policy.display_name == 'HTTP Uptime Check Alerting Policy': found_uptime_alert = True self.assertTrue(found_uptime_alert)
def cleanupPolicies(project_name): """ Delete all alerting policies for both uptime checks and SLOs. """ client = monitoring_v3.AlertPolicyServiceClient() policies = True while policies: policies = list(client.list_alert_policies(project_name)) for policy in policies: try: client.delete_alert_policy(policy.name) except: print('Could not delete alerting policy: ' + policy.name)
def test_create_alert_policy_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) client = monitoring_v3.AlertPolicyServiceClient(channel=channel) # Setup request name = client.project_path('[PROJECT]') alert_policy = {} with pytest.raises(CustomException): client.create_alert_policy(name, alert_policy)
def backup(project_name): alert_client = monitoring_v3.AlertPolicyServiceClient() channel_client = monitoring_v3.NotificationChannelServiceClient() record = { 'project_name': project_name, 'policies': list(alert_client.list_alert_policies(project_name)), 'channels': list(channel_client.list_notification_channels(project_name)) } json.dump(record, open('backup.json', 'wt'), cls=ProtoEncoder, indent=2) print('Backed up alert policies and notification channels to backup.json.')
def test_update_alert_policy(self): client = monitoring_v3.AlertPolicyServiceClient() name_inside = client.alert_policy_path(PROJECT_INSIDE, "mock_alert_policy") delayed_inside = lambda: client.update_alert_policy( {"name": name_inside}) name_outside = client.alert_policy_path(PROJECT_OUTSIDE, "mock_alert_policy") delayed_outside = lambda: client.update_alert_policy( {"name": name_outside}) self._do_test(delayed_inside, delayed_outside)
def create_ca_monitor_policy(project_id: str) -> None: """ Create a monitoring policy that notifies you 30 days before a managed CA expires. Args: project_id: project ID or project number of the Cloud project you want to use. """ alertPolicyServiceClient = monitoring_v3.AlertPolicyServiceClient() notificationChannelServiceClient = monitoring_v3.NotificationChannelServiceClient( ) # Query which indicates the resource to monitor and the constraints. # Here, the alert policy notifies you 30 days before a managed CA expires. # For more information on creating queries, see: https://cloud.google.com/monitoring/mql/alerts query = ( "fetch privateca.googleapis.com/CertificateAuthority" "| metric 'privateca.googleapis.com/ca/cert_chain_expiration'" "| group_by 5m," "[value_cert_chain_expiration_mean: mean(value.cert_chain_expiration)]" "| every 5m" "| condition val() < 2.592e+06 's'") # Create a notification channel. notification_channel = monitoring_v3.NotificationChannel( type_="email", labels={"email_address": "*****@*****.**"}, ) channel = notificationChannelServiceClient.create_notification_channel( name=notificationChannelServiceClient.common_project_path(project_id), notification_channel=notification_channel, ) # Set the query and notification channel. alert_policy = monitoring_v3.AlertPolicy( display_name="policy-name", conditions=[ monitoring_v3.AlertPolicy.Condition( display_name="ca-cert-chain-expiration", condition_monitoring_query_language=monitoring_v3.AlertPolicy. Condition.MonitoringQueryLanguageCondition(query=query, ), ) ], combiner=monitoring_v3.AlertPolicy.ConditionCombinerType.AND, notification_channels=[channel.name], ) policy = alertPolicyServiceClient.create_alert_policy( name=notificationChannelServiceClient.common_project_path(project_id), alert_policy=alert_policy, ) print("Monitoring policy successfully created!", policy.name)
def test_list_alert_policies_exception(self): channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup request name = client.project_path("[PROJECT]") paged_list_response = client.list_alert_policies(name) with pytest.raises(CustomException): list(paged_list_response)
def test_update_alert_policy_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup request alert_policy = {} with pytest.raises(CustomException): client.update_alert_policy(alert_policy)
def test_delete_alert_policy_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup request name = client.alert_policy_path("[PROJECT]", "[ALERT_POLICY]") with pytest.raises(CustomException): client.delete_alert_policy(name)
def backup(project_name, backup_filename): alert_client = monitoring_v3.AlertPolicyServiceClient() channel_client = monitoring_v3.NotificationChannelServiceClient() record = { "project_name": project_name, "policies": list(alert_client.list_alert_policies(name=project_name)), "channels": list(channel_client.list_notification_channels(name=project_name)), } json.dump(record, open(backup_filename, "wt"), cls=ProtoEncoder, indent=2) print( "Backed up alert policies and notification channels to {}.".format( backup_filename ) )
def test_delete_alert_policy(self): channel = ChannelStub() client = monitoring_v3.AlertPolicyServiceClient(channel=channel) # Setup Request name = client.alert_policy_path('[PROJECT]', '[ALERT_POLICY]') client.delete_alert_policy(name) assert len(channel.requests) == 1 expected_request = alert_service_pb2.DeleteAlertPolicyRequest( name=name) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_create_alert_policy_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) patch = mock.patch('google.api_core.grpc_helpers.create_channel') with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup request name = client.project_path('[PROJECT]') alert_policy = {} with pytest.raises(CustomException): client.create_alert_policy(name, alert_policy)
def replace_notification_channels(project_name, alert_policy_id, channel_ids): _, project_id = project_name.split('/') alert_client = monitoring_v3.AlertPolicyServiceClient() channel_client = monitoring_v3.NotificationChannelServiceClient() policy = monitoring_v3.types.alert_pb2.AlertPolicy() policy.name = alert_client.alert_policy_path(project_id, alert_policy_id) for channel_id in channel_ids: policy.notification_channels.append( channel_client.notification_channel_path(project_id, channel_id)) mask = monitoring_v3.types.field_mask_pb2.FieldMask() mask.paths.append('notification_channels') updated_policy = alert_client.update_alert_policy(policy, mask) print('Updated', updated_policy.name)
def test_delete_alert_policy(self): channel = ChannelStub() patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = monitoring_v3.AlertPolicyServiceClient() # Setup Request name = client.alert_policy_path("[PROJECT]", "[ALERT_POLICY]") client.delete_alert_policy(name) assert len(channel.requests) == 1 expected_request = alert_service_pb2.DeleteAlertPolicyRequest(name=name) actual_request = channel.requests[0][1] assert expected_request == actual_request
def replace_notification_channels(project_name, alert_policy_id, channel_ids): _, project_id = project_name.split("/") alert_client = monitoring_v3.AlertPolicyServiceClient() channel_client = monitoring_v3.NotificationChannelServiceClient() policy = monitoring_v3.AlertPolicy() policy.name = alert_client.alert_policy_path(project_id, alert_policy_id) for channel_id in channel_ids: policy.notification_channels.append( channel_client.notification_channel_path(project_id, channel_id)) mask = field_mask.FieldMask() mask.paths.append("notification_channels") updated_policy = alert_client.update_alert_policy(alert_policy=policy, update_mask=mask) print("Updated", updated_policy.name)
def __init__(self): self.project_id = snippets.project_id() self.project_name = snippets.project_name() self.alert_policy_client = monitoring_v3.AlertPolicyServiceClient() self.notification_channel_client = ( monitoring_v3.NotificationChannelServiceClient() ) # delete all existing policies older than 1 hour prior to testing for policy in self.alert_policy_client.list_alert_policies(name=self.project_name): seconds_since_creation = datetime.timestamp(datetime.utcnow())-datetime.timestamp(policy.creation_record.mutate_time) if seconds_since_creation > 3600: try: self.alert_policy_client.delete_alert_policy( name=policy.name ) except NotFound: print("Ignored NotFound when deleting a policy.")
def test_get_alert_policy(self): # Setup Expected Response name_2 = 'name2-1052831874' display_name = 'displayName1615086568' expected_response = {'name': name_2, 'display_name': display_name} expected_response = alert_pb2.AlertPolicy(**expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) client = monitoring_v3.AlertPolicyServiceClient(channel=channel) # Setup Request name = client.alert_policy_path('[PROJECT]', '[ALERT_POLICY]') response = client.get_alert_policy(name) assert expected_response == response assert len(channel.requests) == 1 expected_request = alert_service_pb2.GetAlertPolicyRequest(name=name) actual_request = channel.requests[0][1] assert expected_request == actual_request