def execute()

in gcpdiag/runbook/lb/latency.py [0:0]
80 lines of code
15 McCabe index (conditional complexity)

  def execute(self):
    """Check request count per second 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.REQUEST_COUNT_THRESHOLD) if op.get(
        flags.REQUEST_COUNT_THRESHOLD) is not None else 150
    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)
    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/request_count'
          | filter (resource.forwarding_rule_name == '{fr_name}'  && resource.region == '{region}')
          | align rate(1m)
          | every 1m
          | group_by [], [value_request_count_aggregate: aggregate(value.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/request_count'
          | filter (resource.forwarding_rule_name == '{fr_name}')
          | align rate(1m)
          | every 1m
          | group_by [], [value_request_count_aggregate: aggregate(value.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/request_count'
          | filter (resource.forwarding_rule_name == '{fr_name}'  && resource.region == '{region}')
          | align rate(1m)
          | every 1m
          | group_by [], [value_request_count_aggregate: aggregate(value.request_count)]
          | within 15m
          '''

    try:
      # Execute the query using the monitoring API
      metric = monitoring.query(project_id, query)
      values = []
      if metric:
        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_rc = [
            float(item) for sublist in values for item in sublist
        ]
        self.average_request_count = sum(flattened_values_rc) / (
            len(flattened_values_rc) * 60) if flattened_values_rc else 0
      if self.average_request_count > threshold:
        op.add_failed(forwarding_rule,
                      reason=op.prep_msg(op.FAILURE_REASON,
                                         average_request_count=round(
                                             self.average_request_count, 2),
                                         threshold=threshold),
                      remediation=op.prep_msg(op.FAILURE_REMEDIATION))

      else:
        op.add_ok(forwarding_rule,
                  reason=op.prep_msg(op.SUCCESS_REASON,
                                     average_request_count=round(
                                         self.average_request_count, 2),
                                     threshold=threshold))
      return metric

    except Exception as e:
      # Catch any other errors
      op.info('An unexpected error occurred during LBRequestCount execution.')
      op.info('Error details: ' + str(e))
      raise