v2alpha

package main

import (
	"bytes"
	"os"
	"reflect"

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

func main() {
	// Raw AlertCondition object in YAML format.
	const alertConditionYAML = `
- apiVersion: openslo.com/v2alpha
  kind: AlertCondition
  metadata:
    name: cpu-usage-breach
    labels:
      env: prod
      team: team-a
  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 := v2alpha.NewAlertCondition(
		v2alpha.Metadata{
			Name: "cpu-usage-breach",
			Labels: v2alpha.Labels{
				"team": "team-a",
				"env":  "prod",
			},
		},
		v2alpha.AlertConditionSpec{
			Severity: "page",
			Condition: v2alpha.AlertConditionType{
				Kind:           v2alpha.AlertConditionKindBurnRate,
				Operator:       v2alpha.OperatorLTE,
				Threshold:      ptr(2.0),
				LookbackWindow: v2alpha.NewDurationShorthand(1, v2alpha.DurationShorthandUnitHour),
				AlertAfter:     v2alpha.NewDurationShorthand(5, v2alpha.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.com/v2alpha
  kind: AlertCondition
  metadata:
    labels:
      env: prod
      team: team-a
    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"

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

func main() {
	// Raw AlertNotificationTarget object in YAML format.
	const targetYAML = `
- apiVersion: openslo.com/v2alpha
  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 := v2alpha.NewAlertNotificationTarget(
		v2alpha.Metadata{
			Name: "pd-on-call-notification",
			Labels: v2alpha.Labels{
				"team": "on-call",
				"env":  "prod",
			},
		},
		v2alpha.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.com/v2alpha
  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"

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

func main() {
	// Raw AlertPolicy object in YAML format.
	const alertPolicyYAML = `
- apiVersion: openslo.com/v2alpha
  kind: AlertPolicy
  metadata:
    name: low-priority
    labels:
      env: prod
      team: team-a
  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 := v2alpha.NewAlertPolicy(
		v2alpha.Metadata{
			Name: "low-priority",
			Labels: v2alpha.Labels{
				"team": "team-a",
				"env":  "prod",
			},
		},
		v2alpha.AlertPolicySpec{
			Description:        "Alert policy for low priority notifications which notifies on-call via email",
			AlertWhenBreaching: true,
			Conditions: []v2alpha.AlertPolicyCondition{
				{
					AlertPolicyConditionRef: &v2alpha.AlertPolicyConditionRef{
						ConditionRef: "cpu-usage-breach",
					},
				},
			},
			NotificationTargets: []v2alpha.AlertPolicyNotificationTarget{
				{
					AlertPolicyNotificationTargetRef: &v2alpha.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.com/v2alpha
  kind: AlertPolicy
  metadata:
    labels:
      env: prod
      team: team-a
    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"

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

func main() {
	// Raw DataSource object in YAML format.
	const dataSourceYAML = `
- apiVersion: openslo.com/v2alpha
  kind: DataSource
  metadata:
    labels:
      env: prod
      team: team-a
    name: prometheus
  spec:
    description: Production Prometheus
    connectionDetails:
    - url: http://prometheus.example.com
    type: Prometheus
`
	// Define DataSource programmatically.
	dataSource := v2alpha.NewDataSource(
		v2alpha.Metadata{
			Name: "prometheus",
			Labels: v2alpha.Labels{
				"team": "team-a",
				"env":  "prod",
			},
		},
		v2alpha.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.com/v2alpha
  kind: DataSource
  metadata:
    labels:
      env: prod
      team: team-a
    name: prometheus
  spec:
    connectionDetails:
    - url: http://prometheus.example.com
    description: Production Prometheus
    type: Prometheus

package main

import (
	"bytes"
	"os"
	"reflect"

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

func main() {
	// Raw SLI object in YAML format.
	const sliYAML = `
- apiVersion: openslo.com/v2alpha
  kind: SLI
  metadata:
    labels:
      env: prod
      team: team-a
    name: search-availability
  spec:
    description: X% of search requests are successful
    ratioMetric:
      counter: true
      good:
        dataSourceRef: my-datadog
        spec:
          query: sum:trace.http.request.hits.by_http_status{http.status_code:200}.as_count()
      total:
        dataSourceRef: my-datadog
        spec:
          query: sum:trace.http.request.hits.by_http_status{*}.as_count()
`
	// Define SLI programmatically.
	sli := v2alpha.NewSLI(
		v2alpha.Metadata{
			Name: "search-availability",
			Labels: v2alpha.Labels{
				"team": "team-a",
				"env":  "prod",
			},
		},
		v2alpha.SLISpec{
			Description: "X% of search requests are successful",
			RatioMetric: &v2alpha.SLIRatioMetric{
				Counter: true,
				Good: &v2alpha.SLIMetricSpec{
					DataSourceRef: "my-datadog",
					Spec: map[string]interface{}{
						"query": "sum:trace.http.request.hits.by_http_status{http.status_code:200}.as_count()",
					},
				},
				Total: &v2alpha.SLIMetricSpec{
					DataSourceRef: "my-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.com/v2alpha
  kind: SLI
  metadata:
    labels:
      env: prod
      team: team-a
    name: search-availability
  spec:
    description: X% of search requests are successful
    ratioMetric:
      counter: true
      good:
        dataSourceRef: my-datadog
        spec:
          query: sum:trace.http.request.hits.by_http_status{http.status_code:200}.as_count()
      total:
        dataSourceRef: my-datadog
        spec:
          query: sum:trace.http.request.hits.by_http_status{*}.as_count()

// Raw SLO object in YAML format.
const sloYAML = `
- apiVersion: openslo.com/v2alpha
  kind: SLO
  metadata:
    name: web-availability
    labels:
      env: prod
      team: team-a
  spec:
    description: X% of search requests are successful
    serviceRef: web
    sli:
      metadata:
        name: web-successful-requests-ratio
      spec:
        ratioMetric:
          counter: true
          good:
            dataSourceRef: my-prometheus
            spec:
              query: sum(http_requests{k8s_cluster="prod",component="web",code=~"2xx|4xx"})
          total:
            dataSourceRef: my-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 := v2alpha.NewSLO(
	v2alpha.Metadata{
		Name: "web-availability",
		Labels: v2alpha.Labels{
			"team": "team-a",
			"env":  "prod",
		},
	},
	v2alpha.SLOSpec{
		Description: "X% of search requests are successful",
		ServiceRef:  "web",
		SLI: &v2alpha.SLOSLIInline{
			Metadata: v2alpha.Metadata{
				Name: "web-successful-requests-ratio",
			},
			Spec: v2alpha.SLISpec{
				RatioMetric: &v2alpha.SLIRatioMetric{
					Counter: true,
					Good: &v2alpha.SLIMetricSpec{
						DataSourceRef: "my-prometheus",
						Spec: map[string]any{
							"query": `sum(http_requests{k8s_cluster="prod",component="web",code=~"2xx|4xx"})`,
						},
					},
					Total: &v2alpha.SLIMetricSpec{
						DataSourceRef: "my-prometheus",
						Spec: map[string]any{
							"query": `sum(http_requests{k8s_cluster="prod",component="web"})`,
						},
					},
				},
			},
		},
		TimeWindow: []v2alpha.SLOTimeWindow{
			{
				Duration:  v2alpha.NewDurationShorthand(1, v2alpha.DurationShorthandUnitWeek),
				IsRolling: false,
				Calendar: &v2alpha.SLOCalendar{
					StartTime: "2022-01-01 12:00:00",
					TimeZone:  "America/New_York",
				},
			},
		},
		BudgetingMethod: v2alpha.SLOBudgetingMethodTimeslices,
		Objectives: []v2alpha.SLOObjective{
			{
				DisplayName:     "Good",
				Target:          ptr(0.995),
				TimeSliceTarget: ptr(0.95),
				TimeSliceWindow: ptr(v2alpha.NewDurationShorthand(1, v2alpha.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.com/v2alpha
  kind: SLO
  metadata:
    labels:
      env: prod
      team: team-a
    name: web-availability
  spec:
    budgetingMethod: Timeslices
    description: X% of search requests are successful
    objectives:
    - displayName: Good
      target: 0.995
      timeSliceTarget: 0.95
      timeSliceWindow: 1m
    serviceRef: web
    sli:
      metadata:
        name: web-successful-requests-ratio
      spec:
        ratioMetric:
          counter: true
          good:
            dataSourceRef: my-prometheus
            spec:
              query: sum(http_requests{k8s_cluster="prod",component="web",code=~"2xx|4xx"})
          total:
            dataSourceRef: my-prometheus
            spec:
              query: sum(http_requests{k8s_cluster="prod",component="web"})
    timeWindow:
    - calendar:
        startTime: "2022-01-01 12:00:00"
        timeZone: America/New_York
      duration: 1w
      isRolling: false

package main

import (
	"bytes"
	"os"
	"reflect"

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

func main() {
	// Raw Service object in YAML format.
	const serviceYAML = `
- apiVersion: openslo.com/v2alpha
  kind: Service
  metadata:
    labels:
      env: prod
      team: team-a
    name: example-service
  spec:
    description: Example service description
`
	// Define Service programmatically.
	service := v2alpha.NewService(
		v2alpha.Metadata{
			Name: "example-service",
			Labels: v2alpha.Labels{
				"team": "team-a",
				"env":  "prod",
			},
		},
		v2alpha.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.com/v2alpha
  kind: Service
  metadata:
    labels:
      env: prod
      team: team-a
    name: example-service
  spec:
    description: Example service description