in gcpdiag/runbook/lb/latency.py [0:0]
def execute(self):
"""Check the 5xx error rate for the specified forwarding rule"""
self.forwarding_rule = lb.get_forwarding_rule(
op.get(flags.PROJECT_ID), op.get(flags.FORWARDING_RULE_NAME),
op.get(flags.REGION))
project_id = op.get(flags.PROJECT_ID)
threshold = op.get(flags.ERROR_RATE_THRESHOLD) if op.get(
flags.ERROR_RATE_THRESHOLD) is not None else 1
forwarding_rule = self.forwarding_rule
fr_name = op.get(flags.FORWARDING_RULE_NAME)
load_balancer_type = self.forwarding_rule.load_balancer_type
region = op.get(flags.REGION)
average_error_count = None
average_error_rate = None
query = ''
op.info('Forwarding rule name: ' + str(self.forwarding_rule))
# Construct the MQL query string, incorporating filter and time range
if load_balancer_type == lb.LoadBalancerType.REGIONAL_EXTERNAL_APPLICATION_LB:
query = f'''
fetch http_external_regional_lb_rule
| metric
'loadbalancing.googleapis.com/https/external/regional/backend_request_count'
| filter
(resource.forwarding_rule_name == '{fr_name}' && resource.region == '{region}')
&& (metric.response_code_class == 500)
| align rate(1m)
| every 1m
| group_by [],
[value_backend_request_count_aggregate:
aggregate(value.backend_request_count)]
| within 15m
'''
if load_balancer_type in [
lb.LoadBalancerType.CLASSIC_APPLICATION_LB,
lb.LoadBalancerType.GLOBAL_EXTERNAL_APPLICATION_LB,
]:
query = f'''
fetch https_lb_rule
| metric
'loadbalancing.googleapis.com/https/backend_request_count'
| filter
(resource.forwarding_rule_name == '{fr_name}')
&& (metric.response_code_class == 500)
| align rate(1m)
| every 1m
| group_by [],
[value_backend_request_count_aggregate:
aggregate(value.backend_request_count)]
| within 15m
'''
if load_balancer_type == lb.LoadBalancerType.REGIONAL_INTERNAL_APPLICATION_LB:
query = f'''
fetch internal_http_lb_rule
| metric
'loadbalancing.googleapis.com/https/internal/backend_request_count'
| filter
(resource.forwarding_rule_name == '{fr_name}' && resource.region == '{region}')
&& (metric.response_code_class == 500)
| align rate(1m)
| every 1m
| group_by [],
[value_backend_request_count_aggregate:
aggregate(value.backend_request_count)]
| within 15m
'''
try:
metric = monitoring.query(project_id, query)
values = []
if metric and metric.get('values'):
for _, item in metric.items(
): # Iterate over the items in the metric dictionary
if 'values' in item:
values = item['values']
else:
values = [[0]]
if values is not None:
flattened_values_er = [
float(item) for sublist in values for item in sublist
]
average_error_count = sum(flattened_values_er) / len(
flattened_values_er) if flattened_values_er else 0
if average_error_count is not None and self.average_request_count is not None:
if self.average_request_count > 0:
average_error_rate = average_error_count / self.average_request_count * 100
else:
average_error_rate = 0
if average_error_rate is None:
average_error_rate = 0
if average_error_rate > threshold:
op.add_failed(forwarding_rule,
reason=op.prep_msg(op.FAILURE_REASON,
average_error_rate=round(
average_error_rate, 2),
threshold=threshold),
remediation=op.prep_msg(op.FAILURE_REMEDIATION))
else:
op.add_ok(forwarding_rule,
reason=op.prep_msg(op.SUCCESS_REASON,
average_error_rate=round(
average_error_rate, 2),
threshold=threshold))
return metric
except Exception as e:
# Catch any other errors
op.info('An unexpected error occurred during LbErrorRateCheck execution.')
op.info('Error details: ' + str(e))
raise