// Code generated from semantic convention specification. DO NOT EDIT.

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

// Package cpuconv provides types and functionality for OpenTelemetry semantic
// conventions in the "cpu" namespace.
package cpuconv

import (
	"context"
	"sync"

	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/metric"
	"go.opentelemetry.io/otel/metric/noop"
)

var (
	addOptPool = &sync.Pool{New: func() any { return &[]metric.AddOption{} }}
	recOptPool = &sync.Pool{New: func() any { return &[]metric.RecordOption{} }}
)

// ModeAttr is an attribute conforming to the cpu.mode semantic conventions. It
// represents the mode of the CPU.
type ModeAttr string

var (
	// ModeUser is the none.
	ModeUser ModeAttr = "user"
	// ModeSystem is the none.
	ModeSystem ModeAttr = "system"
	// ModeNice is the none.
	ModeNice ModeAttr = "nice"
	// ModeIdle is the none.
	ModeIdle ModeAttr = "idle"
	// ModeIOWait is the none.
	ModeIOWait ModeAttr = "iowait"
	// ModeInterrupt is the none.
	ModeInterrupt ModeAttr = "interrupt"
	// ModeSteal is the none.
	ModeSteal ModeAttr = "steal"
	// ModeKernel is the none.
	ModeKernel ModeAttr = "kernel"
)

// Frequency is an instrument used to record metric values conforming to the
// "cpu.frequency" semantic conventions. It represents the operating frequency of
// the logical CPU in Hertz.
type Frequency struct {
	metric.Int64Gauge
}

// NewFrequency returns a new Frequency instrument.
func NewFrequency(
	m metric.Meter,
	opt ...metric.Int64GaugeOption,
) (Frequency, error) {
	// Check if the meter is nil.
	if m == nil {
		return Frequency{noop.Int64Gauge{}}, nil
	}

	i, err := m.Int64Gauge(
		"cpu.frequency",
		append([]metric.Int64GaugeOption{
			metric.WithDescription("Operating frequency of the logical CPU in Hertz."),
			metric.WithUnit("Hz"),
		}, opt...)...,
	)
	if err != nil {
		return Frequency{noop.Int64Gauge{}}, err
	}
	return Frequency{i}, nil
}

// Inst returns the underlying metric instrument.
func (m Frequency) Inst() metric.Int64Gauge {
	return m.Int64Gauge
}

// Name returns the semantic convention name of the instrument.
func (Frequency) Name() string {
	return "cpu.frequency"
}

// Unit returns the semantic convention unit of the instrument
func (Frequency) Unit() string {
	return "Hz"
}

// Description returns the semantic convention description of the instrument
func (Frequency) Description() string {
	return "Operating frequency of the logical CPU in Hertz."
}

// Record records val to the current distribution.
//
// All additional attrs passed are included in the recorded value.
func (m Frequency) Record(
	ctx context.Context,
	val int64,
	attrs ...attribute.KeyValue,
) {
	o := recOptPool.Get().(*[]metric.RecordOption)
	defer func() {
		*o = (*o)[:0]
		recOptPool.Put(o)
	}()

	*o = append(
		*o,
		metric.WithAttributes(
			attrs...,
		),
	)

	m.Int64Gauge.Record(ctx, val, *o...)
}

// AttrLogicalNumber returns an optional attribute for the "cpu.logical_number"
// semantic convention. It represents the logical CPU number [0..n-1].
func (Frequency) AttrLogicalNumber(val int) attribute.KeyValue {
	return attribute.Int("cpu.logical_number", val)
}

// Time is an instrument used to record metric values conforming to the
// "cpu.time" semantic conventions. It represents the seconds each logical CPU
// spent on each mode.
type Time struct {
	metric.Float64ObservableCounter
}

// NewTime returns a new Time instrument.
func NewTime(
	m metric.Meter,
	opt ...metric.Float64ObservableCounterOption,
) (Time, error) {
	// Check if the meter is nil.
	if m == nil {
		return Time{noop.Float64ObservableCounter{}}, nil
	}

	i, err := m.Float64ObservableCounter(
		"cpu.time",
		append([]metric.Float64ObservableCounterOption{
			metric.WithDescription("Seconds each logical CPU spent on each mode"),
			metric.WithUnit("s"),
		}, opt...)...,
	)
	if err != nil {
		return Time{noop.Float64ObservableCounter{}}, err
	}
	return Time{i}, nil
}

// Inst returns the underlying metric instrument.
func (m Time) Inst() metric.Float64ObservableCounter {
	return m.Float64ObservableCounter
}

// Name returns the semantic convention name of the instrument.
func (Time) Name() string {
	return "cpu.time"
}

// Unit returns the semantic convention unit of the instrument
func (Time) Unit() string {
	return "s"
}

// Description returns the semantic convention description of the instrument
func (Time) Description() string {
	return "Seconds each logical CPU spent on each mode"
}

// AttrLogicalNumber returns an optional attribute for the "cpu.logical_number"
// semantic convention. It represents the logical CPU number [0..n-1].
func (Time) AttrLogicalNumber(val int) attribute.KeyValue {
	return attribute.Int("cpu.logical_number", val)
}

// AttrMode returns an optional attribute for the "cpu.mode" semantic convention.
// It represents the mode of the CPU.
func (Time) AttrMode(val ModeAttr) attribute.KeyValue {
	return attribute.String("cpu.mode", string(val))
}

// Utilization is an instrument used to record metric values conforming to the
// "cpu.utilization" semantic conventions. It represents the for each logical
// CPU, the utilization is calculated as the change in cumulative CPU time
// (cpu.time) over a measurement interval, divided by the elapsed time.
type Utilization struct {
	metric.Int64Gauge
}

// NewUtilization returns a new Utilization instrument.
func NewUtilization(
	m metric.Meter,
	opt ...metric.Int64GaugeOption,
) (Utilization, error) {
	// Check if the meter is nil.
	if m == nil {
		return Utilization{noop.Int64Gauge{}}, nil
	}

	i, err := m.Int64Gauge(
		"cpu.utilization",
		append([]metric.Int64GaugeOption{
			metric.WithDescription("For each logical CPU, the utilization is calculated as the change in cumulative CPU time (cpu.time) over a measurement interval, divided by the elapsed time."),
			metric.WithUnit("1"),
		}, opt...)...,
	)
	if err != nil {
		return Utilization{noop.Int64Gauge{}}, err
	}
	return Utilization{i}, nil
}

// Inst returns the underlying metric instrument.
func (m Utilization) Inst() metric.Int64Gauge {
	return m.Int64Gauge
}

// Name returns the semantic convention name of the instrument.
func (Utilization) Name() string {
	return "cpu.utilization"
}

// Unit returns the semantic convention unit of the instrument
func (Utilization) Unit() string {
	return "1"
}

// Description returns the semantic convention description of the instrument
func (Utilization) Description() string {
	return "For each logical CPU, the utilization is calculated as the change in cumulative CPU time (cpu.time) over a measurement interval, divided by the elapsed time."
}

// Record records val to the current distribution.
//
// All additional attrs passed are included in the recorded value.
func (m Utilization) Record(
	ctx context.Context,
	val int64,
	attrs ...attribute.KeyValue,
) {
	o := recOptPool.Get().(*[]metric.RecordOption)
	defer func() {
		*o = (*o)[:0]
		recOptPool.Put(o)
	}()

	*o = append(
		*o,
		metric.WithAttributes(
			attrs...,
		),
	)

	m.Int64Gauge.Record(ctx, val, *o...)
}

// AttrLogicalNumber returns an optional attribute for the "cpu.logical_number"
// semantic convention. It represents the logical CPU number [0..n-1].
func (Utilization) AttrLogicalNumber(val int) attribute.KeyValue {
	return attribute.Int("cpu.logical_number", val)
}

// AttrMode returns an optional attribute for the "cpu.mode" semantic convention.
// It represents the mode of the CPU.
func (Utilization) AttrMode(val ModeAttr) attribute.KeyValue {
	return attribute.String("cpu.mode", string(val))
}