v1

package main

import (
	"bytes"
	"os"
	"reflect"

	v1 "github.com/OpenSLO/go-sdk/pkg/openslo/v1"
	"github.com/OpenSLO/go-sdk/pkg/openslosdk"
)

func main() {
	// Raw AlertCondition object in YAML format.
	const alertConditionYAML = `
- apiVersion: openslo/v1
  kind: AlertCondition
  metadata:
    name: cpu-usage-breach
    displayName: CPU usage breach
    labels:
      env:
        - prod
      team:
        - team-a
        - team-b
  spec:
    description: If the CPU usage is too high for given period then it should alert
    severity: page
    condition:
      kind: burnrate
      op: lte
      threshold: 2
      lookbackWindow: 1h
      alertAfter: 5m
`
	// Define AlertCondition programmatically.
	condition := v1.NewAlertCondition(
		v1.Metadata{
			Name:        "cpu-usage-breach",
			DisplayName: "CPU usage breach",
			Labels: v1.Labels{
				"team": {"team-a", "team-b"},
				"env":  {"prod"},
			},
		},
		v1.AlertConditionSpec{
			Severity: "page",
			Condition: v1.AlertConditionType{
				Kind:           v1.AlertConditionKindBurnRate,
				Operator:       v1.OperatorLTE,
				Threshold:      ptr(2.0),
				LookbackWindow: v1.NewDurationShorthand(1, v1.DurationShorthandUnitHour),
				AlertAfter:     ptr(v1.NewDurationShorthand(5, v1.DurationShorthandUnitMinute)),
			},
			Description: "If the CPU usage is too high for given period then it should alert",
		},
	)
	// Read the raw AlertCondition object.
	objects, err := openslosdk.Decode(bytes.NewBufferString(alertConditionYAML), openslosdk.FormatYAML)
	if err != nil {
		panic(err)
	}
	// Compare the raw AlertCondition object with the programmatically defined AlertCondition object.
	if !reflect.DeepEqual(objects[0], condition) {
		panic("AlertCondition objects are not equal!")
	}
	// Validate the AlertCondition object.
	if err = condition.Validate(); err != nil {
		panic(err)
	}
	// Encode the AlertCondition object to YAML and write it to stdout.
	if err = openslosdk.Encode(os.Stdout, openslosdk.FormatYAML, condition); err != nil {
		panic(err)
	}

}

func ptr[T any](v T) *T { return &v }

Output:

- apiVersion: openslo/v1
  kind: AlertCondition
  metadata:
    displayName: CPU usage breach
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: cpu-usage-breach
  spec:
    condition:
      alertAfter: 5m
      kind: burnrate
      lookbackWindow: 1h
      op: lte
      threshold: 2
    description: If the CPU usage is too high for given period then it should alert
    severity: page

package main

import (
	"bytes"
	"os"
	"reflect"

	v1 "github.com/OpenSLO/go-sdk/pkg/openslo/v1"
	"github.com/OpenSLO/go-sdk/pkg/openslosdk"
)

func main() {
	// Raw AlertNotificationTarget object in YAML format.
	const targetYAML = `
- apiVersion: openslo/v1
  kind: AlertNotificationTarget
  metadata:
    labels:
      env:
        - prod
      team:
        - on-call
    name: pd-on-call-notification
  spec:
    description: Sends PagerDuty alert to the current on-call
    target: pagerduty
`
	// Define AlertNotificationTarget programmatically.
	target := v1.NewAlertNotificationTarget(
		v1.Metadata{
			Name: "pd-on-call-notification",
			Labels: v1.Labels{
				"team": {"on-call"},
				"env":  {"prod"},
			},
		},
		v1.AlertNotificationTargetSpec{
			Description: "Sends PagerDuty alert to the current on-call",
			Target:      "pagerduty",
		},
	)
	// Read the raw AlertNotificationTarget object.
	objects, err := openslosdk.Decode(bytes.NewBufferString(targetYAML), openslosdk.FormatYAML)
	if err != nil {
		panic(err)
	}
	// Compare the raw AlertNotificationTarget object with the programmatically defined AlertNotificationTarget object.
	if !reflect.DeepEqual(objects[0], target) {
		panic("AlertNotificationTarget objects are not equal!")
	}
	// Validate the AlertNotificationTarget object.
	if err = target.Validate(); err != nil {
		panic(err)
	}
	// Encode the AlertNotificationTarget object to YAML and write it to stdout.
	if err = openslosdk.Encode(os.Stdout, openslosdk.FormatYAML, target); err != nil {
		panic(err)
	}

}

Output:

- apiVersion: openslo/v1
  kind: AlertNotificationTarget
  metadata:
    labels:
      env:
      - prod
      team:
      - on-call
    name: pd-on-call-notification
  spec:
    description: Sends PagerDuty alert to the current on-call
    target: pagerduty

package main

import (
	"bytes"
	"os"
	"reflect"

	v1 "github.com/OpenSLO/go-sdk/pkg/openslo/v1"
	"github.com/OpenSLO/go-sdk/pkg/openslosdk"
)

func main() {
	// Raw AlertPolicy object in YAML format.
	const alertPolicyYAML = `
- apiVersion: openslo/v1
  kind: AlertPolicy
  metadata:
    name: low-priority
    displayName: Low Priority
    labels:
      env:
        - prod
      team:
        - team-a
        - team-b
  spec:
    description: Alert policy for low priority notifications which notifies on-call via email
    alertWhenBreaching: true
    conditions:
      - conditionRef: cpu-usage-breach
    notificationTargets:
      - targetRef: on-call-mail-notification
`
	// Define AlertPolicy programmatically.
	policy := v1.NewAlertPolicy(
		v1.Metadata{
			Name:        "low-priority",
			DisplayName: "Low Priority",
			Labels: v1.Labels{
				"team": {"team-a", "team-b"},
				"env":  {"prod"},
			},
		},
		v1.AlertPolicySpec{
			Description:        "Alert policy for low priority notifications which notifies on-call via email",
			AlertWhenBreaching: true,
			Conditions: []v1.AlertPolicyCondition{
				{
					AlertPolicyConditionRef: &v1.AlertPolicyConditionRef{
						ConditionRef: "cpu-usage-breach",
					},
				},
			},
			NotificationTargets: []v1.AlertPolicyNotificationTarget{
				{
					AlertPolicyNotificationTargetRef: &v1.AlertPolicyNotificationTargetRef{
						TargetRef: "on-call-mail-notification",
					},
				},
			},
		},
	)
	// Read the raw AlertPolicy object.
	objects, err := openslosdk.Decode(bytes.NewBufferString(alertPolicyYAML), openslosdk.FormatYAML)
	if err != nil {
		panic(err)
	}
	// Compare the raw AlertPolicy object with the programmatically defined AlertPolicy object.
	if !reflect.DeepEqual(objects[0], policy) {
		panic("AlertPolicy objects are not equal!")
	}
	// Validate the AlertPolicy object.
	if err := policy.Validate(); err != nil {
		panic(err)
	}
	// Encode the AlertPolicy object to YAML and write it to stdout.
	if err := openslosdk.Encode(os.Stdout, openslosdk.FormatYAML, policy); err != nil {
		panic(err)
	}

}

Output:

- apiVersion: openslo/v1
  kind: AlertPolicy
  metadata:
    displayName: Low Priority
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: low-priority
  spec:
    alertWhenBreaching: true
    conditions:
    - conditionRef: cpu-usage-breach
    description: Alert policy for low priority notifications which notifies on-call
      via email
    notificationTargets:
    - targetRef: on-call-mail-notification

package main

import (
	"bytes"
	"os"
	"reflect"

	v1 "github.com/OpenSLO/go-sdk/pkg/openslo/v1"
	"github.com/OpenSLO/go-sdk/pkg/openslosdk"
)

func main() {
	// Raw DataSource object in YAML format.
	const dataSourceYAML = `
- apiVersion: openslo/v1
  kind: DataSource
  metadata:
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: prometheus
  spec:
    description: Production Prometheus
    connectionDetails:
    - url: http://prometheus.example.com
    type: Prometheus
`
	// Define DataSource programmatically.
	dataSource := v1.NewDataSource(
		v1.Metadata{
			Name: "prometheus",
			Labels: v1.Labels{
				"team": {"team-a", "team-b"},
				"env":  {"prod"},
			},
		},
		v1.DataSourceSpec{
			Description:       "Production Prometheus",
			Type:              "Prometheus",
			ConnectionDetails: []byte(`[{"url":"http://prometheus.example.com"}]`),
		},
	)
	// Read the raw DataSource object.
	objects, err := openslosdk.Decode(bytes.NewBufferString(dataSourceYAML), openslosdk.FormatYAML)
	if err != nil {
		panic(err)
	}
	// Compare the raw DataSource object with the programmatically defined DataSource object.
	if !reflect.DeepEqual(objects[0], dataSource) {
		panic("DataSource objects are not equal!")
	}
	// Validate the DataSource object.
	if err = dataSource.Validate(); err != nil {
		panic(err)
	}
	// Encode the DataSource object to YAML and write it to stdout.
	if err = openslosdk.Encode(os.Stdout, openslosdk.FormatYAML, dataSource); err != nil {
		panic(err)
	}

}

Output:

- apiVersion: openslo/v1
  kind: DataSource
  metadata:
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: prometheus
  spec:
    connectionDetails:
    - url: http://prometheus.example.com
    description: Production Prometheus
    type: Prometheus

package main

import (
	"bytes"
	"os"
	"reflect"

	v1 "github.com/OpenSLO/go-sdk/pkg/openslo/v1"
	"github.com/OpenSLO/go-sdk/pkg/openslosdk"
)

func main() {
	// Raw SLI object in YAML format.
	const sliYAML = `
- apiVersion: openslo/v1
  kind: SLI
  metadata:
    displayName: Searching availability
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: search-availability
  spec:
    description: X% of search requests are successful
    ratioMetric:
      counter: true
      good:
        metricSource:
          metricSourceRef: my-datadog
          spec:
            query: sum:trace.http.request.hits.by_http_status{http.status_code:200}.as_count()
          type: Datadog
      total:
        metricSource:
          metricSourceRef: my-datadog
          spec:
            query: sum:trace.http.request.hits.by_http_status{*}.as_count()
          type: Datadog
`
	// Define SLI programmatically.
	sli := v1.NewSLI(
		v1.Metadata{
			Name:        "search-availability",
			DisplayName: "Searching availability",
			Labels: v1.Labels{
				"team": {"team-a", "team-b"},
				"env":  {"prod"},
			},
		},
		v1.SLISpec{
			Description: "X% of search requests are successful",
			RatioMetric: &v1.SLIRatioMetric{
				Counter: true,
				Good: &v1.SLIMetricSpec{
					MetricSource: v1.SLIMetricSource{
						MetricSourceRef: "my-datadog",
						Type:            "Datadog",
						Spec: map[string]interface{}{
							"query": "sum:trace.http.request.hits.by_http_status{http.status_code:200}.as_count()",
						},
					},
				},
				Total: &v1.SLIMetricSpec{
					MetricSource: v1.SLIMetricSource{
						MetricSourceRef: "my-datadog",
						Type:            "Datadog",
						Spec: map[string]interface{}{
							"query": "sum:trace.http.request.hits.by_http_status{*}.as_count()",
						},
					},
				},
			},
		},
	)
	// Read the raw SLI object.
	objects, err := openslosdk.Decode(bytes.NewBufferString(sliYAML), openslosdk.FormatYAML)
	if err != nil {
		panic(err)
	}
	// Compare the raw SLI object with the programmatically defined SLI object.
	if !reflect.DeepEqual(objects[0], sli) {
		panic("SLI objects are not equal!")
	}
	// Validate the SLI object.
	if err = sli.Validate(); err != nil {
		panic(err)
	}
	// Encode the SLI object to YAML and write it to stdout.
	if err = openslosdk.Encode(os.Stdout, openslosdk.FormatYAML, sli); err != nil {
		panic(err)
	}

}

Output:

- apiVersion: openslo/v1
  kind: SLI
  metadata:
    displayName: Searching availability
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: search-availability
  spec:
    description: X% of search requests are successful
    ratioMetric:
      counter: true
      good:
        metricSource:
          metricSourceRef: my-datadog
          spec:
            query: sum:trace.http.request.hits.by_http_status{http.status_code:200}.as_count()
          type: Datadog
      total:
        metricSource:
          metricSourceRef: my-datadog
          spec:
            query: sum:trace.http.request.hits.by_http_status{*}.as_count()
          type: Datadog

// Raw SLO object in YAML format.
const sloYAML = `
- apiVersion: openslo/v1
  kind: SLO
  metadata:
    name: web-availability
    displayName: SLO for web availability
    labels:
      env:
        - prod
      team:
        - team-a
        - team-b
  spec:
    description: X% of search requests are successful
    service: web
    indicator:
      metadata:
        name: web-successful-requests-ratio
      spec:
        ratioMetric:
          counter: true
          good:
            metricSource:
              type: Prometheus
              spec:
                query: sum(http_requests{k8s_cluster="prod",component="web",code=~"2xx|4xx"})
          total:
            metricSource:
              type: Prometheus
              spec:
                query: sum(http_requests{k8s_cluster="prod",component="web"})
    timeWindow:
      - duration: 1w
        isRolling: false
        calendar:
          startTime: 2022-01-01 12:00:00
          timeZone: America/New_York
    budgetingMethod: Timeslices
    objectives:
      - displayName: Good
        target: 0.995
        timeSliceTarget: 0.95
        timeSliceWindow: 1m
`
// Define SLO programmatically.
slo := v1.NewSLO(
	v1.Metadata{
		Name:        "web-availability",
		DisplayName: "SLO for web availability",
		Labels: v1.Labels{
			"team": {"team-a", "team-b"},
			"env":  {"prod"},
		},
	},
	v1.SLOSpec{
		Description: "X% of search requests are successful",
		Service:     "web",
		Indicator: &v1.SLOIndicatorInline{
			Metadata: v1.Metadata{
				Name: "web-successful-requests-ratio",
			},
			Spec: v1.SLISpec{
				RatioMetric: &v1.SLIRatioMetric{
					Counter: true,
					Good: &v1.SLIMetricSpec{
						MetricSource: v1.SLIMetricSource{
							Type: "Prometheus",
							Spec: map[string]any{
								"query": `sum(http_requests{k8s_cluster="prod",component="web",code=~"2xx|4xx"})`,
							},
						},
					},
					Total: &v1.SLIMetricSpec{
						MetricSource: v1.SLIMetricSource{
							Type: "Prometheus",
							Spec: map[string]any{
								"query": `sum(http_requests{k8s_cluster="prod",component="web"})`,
							},
						},
					},
				},
			},
		},
		TimeWindow: []v1.SLOTimeWindow{
			{
				Duration:  v1.NewDurationShorthand(1, v1.DurationShorthandUnitWeek),
				IsRolling: false,
				Calendar: &v1.SLOCalendar{
					StartTime: "2022-01-01 12:00:00",
					TimeZone:  "America/New_York",
				},
			},
		},
		BudgetingMethod: v1.SLOBudgetingMethodTimeslices,
		Objectives: []v1.SLOObjective{
			{
				DisplayName:     "Good",
				Target:          ptr(0.995),
				TimeSliceTarget: ptr(0.95),
				TimeSliceWindow: ptr(v1.NewDurationShorthand(1, v1.DurationShorthandUnitMinute)),
			},
		},
	},
)
// Read the raw SLO object.
objects, err := openslosdk.Decode(bytes.NewBufferString(sloYAML), openslosdk.FormatYAML)
if err != nil {
	panic(err)
}
// Compare the raw SLO object with the programmatically defined SLO object.
if !reflect.DeepEqual(objects[0], slo) {
	panic("SLO objects are not equal!")
}
// Validate the SLO object.
if err = slo.Validate(); err != nil {
	panic(err)
}
// Encode the SLO object to YAML and write it to stdout.
if err = openslosdk.Encode(os.Stdout, openslosdk.FormatYAML, slo); err != nil {
	panic(err)
}

Output:

- apiVersion: openslo/v1
  kind: SLO
  metadata:
    displayName: SLO for web availability
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: web-availability
  spec:
    budgetingMethod: Timeslices
    description: X% of search requests are successful
    indicator:
      metadata:
        name: web-successful-requests-ratio
      spec:
        ratioMetric:
          counter: true
          good:
            metricSource:
              spec:
                query: sum(http_requests{k8s_cluster="prod",component="web",code=~"2xx|4xx"})
              type: Prometheus
          total:
            metricSource:
              spec:
                query: sum(http_requests{k8s_cluster="prod",component="web"})
              type: Prometheus
    objectives:
    - displayName: Good
      target: 0.995
      timeSliceTarget: 0.95
      timeSliceWindow: 1m
    service: web
    timeWindow:
    - calendar:
        startTime: "2022-01-01 12:00:00"
        timeZone: America/New_York
      duration: 1w
      isRolling: false

package main

import (
	"bytes"
	"os"
	"reflect"

	v1 "github.com/OpenSLO/go-sdk/pkg/openslo/v1"
	"github.com/OpenSLO/go-sdk/pkg/openslosdk"
)

func main() {
	// Raw Service object in YAML format.
	const serviceYAML = `
- apiVersion: openslo/v1
  kind: Service
  metadata:
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: example-service
  spec:
    description: Example service description
`
	// Define Service programmatically.
	service := v1.NewService(
		v1.Metadata{
			Name: "example-service",
			Labels: v1.Labels{
				"team": {"team-a", "team-b"},
				"env":  {"prod"},
			},
		},
		v1.ServiceSpec{
			Description: "Example service description",
		},
	)
	// Read the raw Service object.
	objects, err := openslosdk.Decode(bytes.NewBufferString(serviceYAML), openslosdk.FormatYAML)
	if err != nil {
		panic(err)
	}
	// Compare the raw Service object with the programmatically defined Service object.
	if !reflect.DeepEqual(objects[0], service) {
		panic("Service objects are not equal!")
	}
	// Validate the Service object.
	if err = service.Validate(); err != nil {
		panic(err)
	}
	// Encode the Service object to YAML and write it to stdout.
	if err = openslosdk.Encode(os.Stdout, openslosdk.FormatYAML, service); err != nil {
		panic(err)
	}

}

Output:

- apiVersion: openslo/v1
  kind: Service
  metadata:
    labels:
      env:
      - prod
      team:
      - team-a
      - team-b
    name: example-service
  spec:
    description: Example service description