func generate()

in tooling/prometheus-rules/main.go [249:319]
65 lines of code
14 McCabe index (conditional complexity)

func generate(inputRules []alertingRuleFile, output io.WriteCloser) error {
	defer func() {
		if err := output.Close(); err != nil {
			logrus.WithError(err).Error("failed to close output file")
		}
	}()

	if _, err := output.Write([]byte(`param azureMonitoring string
`)); err != nil {
		return err
	}

	for _, irf := range inputRules {
		for _, group := range irf.rules.Spec.Groups {
			logger := logrus.WithFields(logrus.Fields{
				"group": group.Name,
			})
			if group.QueryOffset != nil {
				logger.Warn("query offset is not supported in Microsoft.AlertsManagement/prometheusRuleGroups")
			}
			if group.Limit != nil {
				logger.Warn("alert limit is not supported in Microsoft.AlertsManagement/prometheusRuleGroups")
			}
			armGroup := armalertsmanagement.PrometheusRuleGroupResource{
				Name: ptr.To(group.Name),
				Properties: &armalertsmanagement.PrometheusRuleGroupProperties{
					Interval: formatDuration(group.Interval),
					Enabled:  ptr.To(true),
				},
			}

			for _, rule := range group.Rules {
				labels := map[string]*string{}
				for k, v := range group.Labels {
					labels[k] = ptr.To(strings.ReplaceAll(v, "'", "\\'"))
				}
				for k, v := range rule.Labels {
					labels[k] = ptr.To(strings.ReplaceAll(v, "'", "\\'"))
				}

				annotations := map[string]*string{}
				for k, v := range rule.Annotations {
					annotations[k] = ptr.To(strings.ReplaceAll(v, "'", "\\'"))
				}
				if rule.Alert != "" {
					armGroup.Properties.Rules = append(armGroup.Properties.Rules, &armalertsmanagement.PrometheusRule{
						Alert:       ptr.To(rule.Alert),
						Enabled:     ptr.To(true),
						Labels:      labels,
						Annotations: annotations,
						For:         formatDuration(rule.For),
						Expression: ptr.To(
							strings.TrimSpace(
								strings.ReplaceAll(rule.Expr.String(), "\n", " "),
							),
						),
						Severity: severityFor(labels),
					})
				}
			}

			if len(armGroup.Properties.Rules) > 0 {
				if err := writeGroups(armGroup, output); err != nil {
					return err
				}
			}
		}

	}
	return nil
}