// Code generated from semantic convention specification. DO NOT EDIT. // Copyright The OpenTelemetry Authors // SPDX-License-Identifier: Apache-2.0 // Package hwconv provides types and functionality for OpenTelemetry semantic // conventions in the "hw" namespace. package hwconv 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{} }} ) // ErrorTypeAttr is an attribute conforming to the error.type semantic // conventions. It represents the type of error encountered by the component. type ErrorTypeAttr string var ( // ErrorTypeOther is a fallback error value to be used when the instrumentation // doesn't define a custom value. ErrorTypeOther ErrorTypeAttr = "_OTHER" ) // BatteryStateAttr is an attribute conforming to the hw.battery.state semantic // conventions. It represents the current state of the battery. type BatteryStateAttr string var ( // BatteryStateCharging is the charging. BatteryStateCharging BatteryStateAttr = "charging" // BatteryStateDischarging is the discharging. BatteryStateDischarging BatteryStateAttr = "discharging" ) // GpuTaskAttr is an attribute conforming to the hw.gpu.task semantic // conventions. It represents the type of task the GPU is performing. type GpuTaskAttr string var ( // GpuTaskDecoder is the decoder. GpuTaskDecoder GpuTaskAttr = "decoder" // GpuTaskEncoder is the encoder. GpuTaskEncoder GpuTaskAttr = "encoder" // GpuTaskGeneral is the general. GpuTaskGeneral GpuTaskAttr = "general" ) // LimitTypeAttr is an attribute conforming to the hw.limit_type semantic // conventions. It represents the represents battery charge level thresholds // relevant to device operation and health. Each `limit_type` denotes a specific // charge limit such as the minimum or maximum optimal charge, the shutdown // threshold, or energy-saving thresholds. These values are typically provided by // the hardware or firmware to guide safe and efficient battery usage. type LimitTypeAttr string var ( // LimitTypeCritical is the critical. LimitTypeCritical LimitTypeAttr = "critical" // LimitTypeDegraded is the degraded. LimitTypeDegraded LimitTypeAttr = "degraded" // LimitTypeHighCritical is the high Critical. LimitTypeHighCritical LimitTypeAttr = "high.critical" // LimitTypeHighDegraded is the high Degraded. LimitTypeHighDegraded LimitTypeAttr = "high.degraded" // LimitTypeLowCritical is the low Critical. LimitTypeLowCritical LimitTypeAttr = "low.critical" // LimitTypeLowDegraded is the low Degraded. LimitTypeLowDegraded LimitTypeAttr = "low.degraded" // LimitTypeMax is the maximum. LimitTypeMax LimitTypeAttr = "max" // LimitTypeThrottled is the throttled. LimitTypeThrottled LimitTypeAttr = "throttled" // LimitTypeTurbo is the turbo. LimitTypeTurbo LimitTypeAttr = "turbo" ) // LogicalDiskStateAttr is an attribute conforming to the hw.logical_disk.state // semantic conventions. It represents the state of the logical disk space usage. type LogicalDiskStateAttr string var ( // LogicalDiskStateUsed is the used. LogicalDiskStateUsed LogicalDiskStateAttr = "used" // LogicalDiskStateFree is the free. LogicalDiskStateFree LogicalDiskStateAttr = "free" ) // PhysicalDiskStateAttr is an attribute conforming to the hw.physical_disk.state // semantic conventions. It represents the state of the physical disk endurance // utilization. type PhysicalDiskStateAttr string var ( // PhysicalDiskStateRemaining is the remaining. PhysicalDiskStateRemaining PhysicalDiskStateAttr = "remaining" ) // StateAttr is an attribute conforming to the hw.state semantic conventions. It // represents the current state of the component. type StateAttr string var ( // StateDegraded is the degraded. StateDegraded StateAttr = "degraded" // StateFailed is the failed. StateFailed StateAttr = "failed" // StateNeedsCleaning is the needs Cleaning. StateNeedsCleaning StateAttr = "needs_cleaning" // StateOk is the OK. StateOk StateAttr = "ok" // StatePredictedFailure is the predicted Failure. StatePredictedFailure StateAttr = "predicted_failure" ) // TapeDriveOperationTypeAttr is an attribute conforming to the // hw.tape_drive.operation_type semantic conventions. It represents the type of // tape drive operation. type TapeDriveOperationTypeAttr string var ( // TapeDriveOperationTypeMount is the mount. TapeDriveOperationTypeMount TapeDriveOperationTypeAttr = "mount" // TapeDriveOperationTypeUnmount is the unmount. TapeDriveOperationTypeUnmount TapeDriveOperationTypeAttr = "unmount" // TapeDriveOperationTypeClean is the clean. TapeDriveOperationTypeClean TapeDriveOperationTypeAttr = "clean" ) // TypeAttr is an attribute conforming to the hw.type semantic conventions. It // represents the type of the component. type TypeAttr string var ( // TypeBattery is the battery. TypeBattery TypeAttr = "battery" // TypeCPU is the CPU. TypeCPU TypeAttr = "cpu" // TypeDiskController is the disk controller. TypeDiskController TypeAttr = "disk_controller" // TypeEnclosure is the enclosure. TypeEnclosure TypeAttr = "enclosure" // TypeFan is the fan. TypeFan TypeAttr = "fan" // TypeGpu is the GPU. TypeGpu TypeAttr = "gpu" // TypeLogicalDisk is the logical disk. TypeLogicalDisk TypeAttr = "logical_disk" // TypeMemory is the memory. TypeMemory TypeAttr = "memory" // TypeNetwork is the network. TypeNetwork TypeAttr = "network" // TypePhysicalDisk is the physical disk. TypePhysicalDisk TypeAttr = "physical_disk" // TypePowerSupply is the power supply. TypePowerSupply TypeAttr = "power_supply" // TypeTapeDrive is the tape drive. TypeTapeDrive TypeAttr = "tape_drive" // TypeTemperature is the temperature. TypeTemperature TypeAttr = "temperature" // TypeVoltage is the voltage. TypeVoltage TypeAttr = "voltage" ) // NetworkIODirectionAttr is an attribute conforming to the network.io.direction // semantic conventions. It represents the direction of network traffic for // network errors. type NetworkIODirectionAttr string var ( // NetworkIODirectionTransmit is the standardized value "transmit" of // NetworkIODirectionAttr. NetworkIODirectionTransmit NetworkIODirectionAttr = "transmit" // NetworkIODirectionReceive is the standardized value "receive" of // NetworkIODirectionAttr. NetworkIODirectionReceive NetworkIODirectionAttr = "receive" ) // BatteryCharge is an instrument used to record metric values conforming to the // "hw.battery.charge" semantic conventions. It represents the remaining fraction // of battery charge. type BatteryCharge struct { metric.Int64Gauge } var newBatteryChargeOpts = []metric.Int64GaugeOption{ metric.WithDescription("Remaining fraction of battery charge."), metric.WithUnit("1"), } // NewBatteryCharge returns a new BatteryCharge instrument. func NewBatteryCharge( m metric.Meter, opt ...metric.Int64GaugeOption, ) (BatteryCharge, error) { // Check if the meter is nil. if m == nil { return BatteryCharge{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newBatteryChargeOpts } else { opt = append(opt, newBatteryChargeOpts...) } i, err := m.Int64Gauge( "hw.battery.charge", opt..., ) if err != nil { return BatteryCharge{noop.Int64Gauge{}}, err } return BatteryCharge{i}, nil } // Inst returns the underlying metric instrument. func (m BatteryCharge) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (BatteryCharge) Name() string { return "hw.battery.charge" } // Unit returns the semantic convention unit of the instrument func (BatteryCharge) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (BatteryCharge) Description() string { return "Remaining fraction of battery charge." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m BatteryCharge) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m BatteryCharge) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrBatteryCapacity returns an optional attribute for the // "hw.battery.capacity" semantic convention. It represents the design capacity // in Watts-hours or Amper-hours. func (BatteryCharge) AttrBatteryCapacity(val string) attribute.KeyValue { return attribute.String("hw.battery.capacity", val) } // AttrBatteryChemistry returns an optional attribute for the // "hw.battery.chemistry" semantic convention. It represents the battery // [chemistry], e.g. Lithium-Ion, Nickel-Cadmium, etc. // // [chemistry]: https://schemas.dmtf.org/wbem/cim-html/2.31.0/CIM_Battery.html func (BatteryCharge) AttrBatteryChemistry(val string) attribute.KeyValue { return attribute.String("hw.battery.chemistry", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (BatteryCharge) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (BatteryCharge) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (BatteryCharge) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (BatteryCharge) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // BatteryChargeLimit is an instrument used to record metric values conforming to // the "hw.battery.charge.limit" semantic conventions. It represents the lower // limit of battery charge fraction to ensure proper operation. type BatteryChargeLimit struct { metric.Int64Gauge } var newBatteryChargeLimitOpts = []metric.Int64GaugeOption{ metric.WithDescription("Lower limit of battery charge fraction to ensure proper operation."), metric.WithUnit("1"), } // NewBatteryChargeLimit returns a new BatteryChargeLimit instrument. func NewBatteryChargeLimit( m metric.Meter, opt ...metric.Int64GaugeOption, ) (BatteryChargeLimit, error) { // Check if the meter is nil. if m == nil { return BatteryChargeLimit{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newBatteryChargeLimitOpts } else { opt = append(opt, newBatteryChargeLimitOpts...) } i, err := m.Int64Gauge( "hw.battery.charge.limit", opt..., ) if err != nil { return BatteryChargeLimit{noop.Int64Gauge{}}, err } return BatteryChargeLimit{i}, nil } // Inst returns the underlying metric instrument. func (m BatteryChargeLimit) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (BatteryChargeLimit) Name() string { return "hw.battery.charge.limit" } // Unit returns the semantic convention unit of the instrument func (BatteryChargeLimit) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (BatteryChargeLimit) Description() string { return "Lower limit of battery charge fraction to ensure proper operation." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m BatteryChargeLimit) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m BatteryChargeLimit) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrBatteryCapacity returns an optional attribute for the // "hw.battery.capacity" semantic convention. It represents the design capacity // in Watts-hours or Amper-hours. func (BatteryChargeLimit) AttrBatteryCapacity(val string) attribute.KeyValue { return attribute.String("hw.battery.capacity", val) } // AttrBatteryChemistry returns an optional attribute for the // "hw.battery.chemistry" semantic convention. It represents the battery // [chemistry], e.g. Lithium-Ion, Nickel-Cadmium, etc. // // [chemistry]: https://schemas.dmtf.org/wbem/cim-html/2.31.0/CIM_Battery.html func (BatteryChargeLimit) AttrBatteryChemistry(val string) attribute.KeyValue { return attribute.String("hw.battery.chemistry", val) } // AttrLimitType returns an optional attribute for the "hw.limit_type" semantic // convention. It represents the represents battery charge level thresholds // relevant to device operation and health. Each `limit_type` denotes a specific // charge limit such as the minimum or maximum optimal charge, the shutdown // threshold, or energy-saving thresholds. These values are typically provided by // the hardware or firmware to guide safe and efficient battery usage. func (BatteryChargeLimit) AttrLimitType(val LimitTypeAttr) attribute.KeyValue { return attribute.String("hw.limit_type", string(val)) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (BatteryChargeLimit) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (BatteryChargeLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (BatteryChargeLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (BatteryChargeLimit) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // BatteryTimeLeft is an instrument used to record metric values conforming to // the "hw.battery.time_left" semantic conventions. It represents the time left // before battery is completely charged or discharged. type BatteryTimeLeft struct { metric.Float64Gauge } var newBatteryTimeLeftOpts = []metric.Float64GaugeOption{ metric.WithDescription("Time left before battery is completely charged or discharged."), metric.WithUnit("s"), } // NewBatteryTimeLeft returns a new BatteryTimeLeft instrument. func NewBatteryTimeLeft( m metric.Meter, opt ...metric.Float64GaugeOption, ) (BatteryTimeLeft, error) { // Check if the meter is nil. if m == nil { return BatteryTimeLeft{noop.Float64Gauge{}}, nil } if len(opt) == 0 { opt = newBatteryTimeLeftOpts } else { opt = append(opt, newBatteryTimeLeftOpts...) } i, err := m.Float64Gauge( "hw.battery.time_left", opt..., ) if err != nil { return BatteryTimeLeft{noop.Float64Gauge{}}, err } return BatteryTimeLeft{i}, nil } // Inst returns the underlying metric instrument. func (m BatteryTimeLeft) Inst() metric.Float64Gauge { return m.Float64Gauge } // Name returns the semantic convention name of the instrument. func (BatteryTimeLeft) Name() string { return "hw.battery.time_left" } // Unit returns the semantic convention unit of the instrument func (BatteryTimeLeft) Unit() string { return "s" } // Description returns the semantic convention description of the instrument func (BatteryTimeLeft) Description() string { return "Time left before battery is completely charged or discharged." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The state is the the current state of the component // // All additional attrs passed are included in the recorded value. func (m BatteryTimeLeft) Record( ctx context.Context, val float64, id string, state StateAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Float64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.state", string(state)), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.state", string(state)), )..., ), ) m.Float64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m BatteryTimeLeft) RecordSet(ctx context.Context, val float64, set attribute.Set) { if set.Len() == 0 { m.Float64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Float64Gauge.Record(ctx, val, *o...) } // AttrBatteryState returns an optional attribute for the "hw.battery.state" // semantic convention. It represents the current state of the battery. func (BatteryTimeLeft) AttrBatteryState(val BatteryStateAttr) attribute.KeyValue { return attribute.String("hw.battery.state", string(val)) } // AttrBatteryCapacity returns an optional attribute for the // "hw.battery.capacity" semantic convention. It represents the design capacity // in Watts-hours or Amper-hours. func (BatteryTimeLeft) AttrBatteryCapacity(val string) attribute.KeyValue { return attribute.String("hw.battery.capacity", val) } // AttrBatteryChemistry returns an optional attribute for the // "hw.battery.chemistry" semantic convention. It represents the battery // [chemistry], e.g. Lithium-Ion, Nickel-Cadmium, etc. // // [chemistry]: https://schemas.dmtf.org/wbem/cim-html/2.31.0/CIM_Battery.html func (BatteryTimeLeft) AttrBatteryChemistry(val string) attribute.KeyValue { return attribute.String("hw.battery.chemistry", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (BatteryTimeLeft) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (BatteryTimeLeft) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (BatteryTimeLeft) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (BatteryTimeLeft) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // CPUSpeed is an instrument used to record metric values conforming to the // "hw.cpu.speed" semantic conventions. It represents the CPU current frequency. type CPUSpeed struct { metric.Int64Gauge } var newCPUSpeedOpts = []metric.Int64GaugeOption{ metric.WithDescription("CPU current frequency."), metric.WithUnit("Hz"), } // NewCPUSpeed returns a new CPUSpeed instrument. func NewCPUSpeed( m metric.Meter, opt ...metric.Int64GaugeOption, ) (CPUSpeed, error) { // Check if the meter is nil. if m == nil { return CPUSpeed{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newCPUSpeedOpts } else { opt = append(opt, newCPUSpeedOpts...) } i, err := m.Int64Gauge( "hw.cpu.speed", opt..., ) if err != nil { return CPUSpeed{noop.Int64Gauge{}}, err } return CPUSpeed{i}, nil } // Inst returns the underlying metric instrument. func (m CPUSpeed) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (CPUSpeed) Name() string { return "hw.cpu.speed" } // Unit returns the semantic convention unit of the instrument func (CPUSpeed) Unit() string { return "Hz" } // Description returns the semantic convention description of the instrument func (CPUSpeed) Description() string { return "CPU current frequency." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m CPUSpeed) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m CPUSpeed) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (CPUSpeed) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (CPUSpeed) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (CPUSpeed) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (CPUSpeed) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // CPUSpeedLimit is an instrument used to record metric values conforming to the // "hw.cpu.speed.limit" semantic conventions. It represents the CPU maximum // frequency. type CPUSpeedLimit struct { metric.Int64Gauge } var newCPUSpeedLimitOpts = []metric.Int64GaugeOption{ metric.WithDescription("CPU maximum frequency."), metric.WithUnit("Hz"), } // NewCPUSpeedLimit returns a new CPUSpeedLimit instrument. func NewCPUSpeedLimit( m metric.Meter, opt ...metric.Int64GaugeOption, ) (CPUSpeedLimit, error) { // Check if the meter is nil. if m == nil { return CPUSpeedLimit{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newCPUSpeedLimitOpts } else { opt = append(opt, newCPUSpeedLimitOpts...) } i, err := m.Int64Gauge( "hw.cpu.speed.limit", opt..., ) if err != nil { return CPUSpeedLimit{noop.Int64Gauge{}}, err } return CPUSpeedLimit{i}, nil } // Inst returns the underlying metric instrument. func (m CPUSpeedLimit) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (CPUSpeedLimit) Name() string { return "hw.cpu.speed.limit" } // Unit returns the semantic convention unit of the instrument func (CPUSpeedLimit) Unit() string { return "Hz" } // Description returns the semantic convention description of the instrument func (CPUSpeedLimit) Description() string { return "CPU maximum frequency." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m CPUSpeedLimit) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m CPUSpeedLimit) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrLimitType returns an optional attribute for the "hw.limit_type" semantic // convention. It represents the type of limit for hardware components. func (CPUSpeedLimit) AttrLimitType(val LimitTypeAttr) attribute.KeyValue { return attribute.String("hw.limit_type", string(val)) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (CPUSpeedLimit) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (CPUSpeedLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (CPUSpeedLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (CPUSpeedLimit) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // Energy is an instrument used to record metric values conforming to the // "hw.energy" semantic conventions. It represents the energy consumed by the // component. type Energy struct { metric.Int64Counter } var newEnergyOpts = []metric.Int64CounterOption{ metric.WithDescription("Energy consumed by the component."), metric.WithUnit("J"), } // NewEnergy returns a new Energy instrument. func NewEnergy( m metric.Meter, opt ...metric.Int64CounterOption, ) (Energy, error) { // Check if the meter is nil. if m == nil { return Energy{noop.Int64Counter{}}, nil } if len(opt) == 0 { opt = newEnergyOpts } else { opt = append(opt, newEnergyOpts...) } i, err := m.Int64Counter( "hw.energy", opt..., ) if err != nil { return Energy{noop.Int64Counter{}}, err } return Energy{i}, nil } // Inst returns the underlying metric instrument. func (m Energy) Inst() metric.Int64Counter { return m.Int64Counter } // Name returns the semantic convention name of the instrument. func (Energy) Name() string { return "hw.energy" } // Unit returns the semantic convention unit of the instrument func (Energy) Unit() string { return "J" } // Description returns the semantic convention description of the instrument func (Energy) Description() string { return "Energy consumed by the component." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The hwType is the type of the component // // All additional attrs passed are included in the recorded value. func (m Energy) Add( ctx context.Context, incr int64, id string, hwType TypeAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.type", string(hwType)), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.type", string(hwType)), )..., ), ) m.Int64Counter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m Energy) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64Counter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Counter.Add(ctx, incr, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Energy) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (Energy) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // Errors is an instrument used to record metric values conforming to the // "hw.errors" semantic conventions. It represents the number of errors // encountered by the component. type Errors struct { metric.Int64Counter } var newErrorsOpts = []metric.Int64CounterOption{ metric.WithDescription("Number of errors encountered by the component."), metric.WithUnit("{error}"), } // NewErrors returns a new Errors instrument. func NewErrors( m metric.Meter, opt ...metric.Int64CounterOption, ) (Errors, error) { // Check if the meter is nil. if m == nil { return Errors{noop.Int64Counter{}}, nil } if len(opt) == 0 { opt = newErrorsOpts } else { opt = append(opt, newErrorsOpts...) } i, err := m.Int64Counter( "hw.errors", opt..., ) if err != nil { return Errors{noop.Int64Counter{}}, err } return Errors{i}, nil } // Inst returns the underlying metric instrument. func (m Errors) Inst() metric.Int64Counter { return m.Int64Counter } // Name returns the semantic convention name of the instrument. func (Errors) Name() string { return "hw.errors" } // Unit returns the semantic convention unit of the instrument func (Errors) Unit() string { return "{error}" } // Description returns the semantic convention description of the instrument func (Errors) Description() string { return "Number of errors encountered by the component." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The hwType is the type of the component // // All additional attrs passed are included in the recorded value. func (m Errors) Add( ctx context.Context, incr int64, id string, hwType TypeAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.type", string(hwType)), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.type", string(hwType)), )..., ), ) m.Int64Counter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m Errors) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64Counter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Counter.Add(ctx, incr, *o...) } // AttrErrorType returns an optional attribute for the "error.type" semantic // convention. It represents the type of error encountered by the component. func (Errors) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue { return attribute.String("error.type", string(val)) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Errors) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (Errors) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrNetworkIODirection returns an optional attribute for the // "network.io.direction" semantic convention. It represents the direction of // network traffic for network errors. func (Errors) AttrNetworkIODirection(val NetworkIODirectionAttr) attribute.KeyValue { return attribute.String("network.io.direction", string(val)) } // FanSpeed is an instrument used to record metric values conforming to the // "hw.fan.speed" semantic conventions. It represents the fan speed in // revolutions per minute. type FanSpeed struct { metric.Int64Gauge } var newFanSpeedOpts = []metric.Int64GaugeOption{ metric.WithDescription("Fan speed in revolutions per minute."), metric.WithUnit("rpm"), } // NewFanSpeed returns a new FanSpeed instrument. func NewFanSpeed( m metric.Meter, opt ...metric.Int64GaugeOption, ) (FanSpeed, error) { // Check if the meter is nil. if m == nil { return FanSpeed{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newFanSpeedOpts } else { opt = append(opt, newFanSpeedOpts...) } i, err := m.Int64Gauge( "hw.fan.speed", opt..., ) if err != nil { return FanSpeed{noop.Int64Gauge{}}, err } return FanSpeed{i}, nil } // Inst returns the underlying metric instrument. func (m FanSpeed) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (FanSpeed) Name() string { return "hw.fan.speed" } // Unit returns the semantic convention unit of the instrument func (FanSpeed) Unit() string { return "rpm" } // Description returns the semantic convention description of the instrument func (FanSpeed) Description() string { return "Fan speed in revolutions per minute." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m FanSpeed) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m FanSpeed) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (FanSpeed) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (FanSpeed) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (FanSpeed) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) } // FanSpeedLimit is an instrument used to record metric values conforming to the // "hw.fan.speed.limit" semantic conventions. It represents the speed limit in // rpm. type FanSpeedLimit struct { metric.Int64Gauge } var newFanSpeedLimitOpts = []metric.Int64GaugeOption{ metric.WithDescription("Speed limit in rpm."), metric.WithUnit("rpm"), } // NewFanSpeedLimit returns a new FanSpeedLimit instrument. func NewFanSpeedLimit( m metric.Meter, opt ...metric.Int64GaugeOption, ) (FanSpeedLimit, error) { // Check if the meter is nil. if m == nil { return FanSpeedLimit{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newFanSpeedLimitOpts } else { opt = append(opt, newFanSpeedLimitOpts...) } i, err := m.Int64Gauge( "hw.fan.speed.limit", opt..., ) if err != nil { return FanSpeedLimit{noop.Int64Gauge{}}, err } return FanSpeedLimit{i}, nil } // Inst returns the underlying metric instrument. func (m FanSpeedLimit) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (FanSpeedLimit) Name() string { return "hw.fan.speed.limit" } // Unit returns the semantic convention unit of the instrument func (FanSpeedLimit) Unit() string { return "rpm" } // Description returns the semantic convention description of the instrument func (FanSpeedLimit) Description() string { return "Speed limit in rpm." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m FanSpeedLimit) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m FanSpeedLimit) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrLimitType returns an optional attribute for the "hw.limit_type" semantic // convention. It represents the type of limit for hardware components. func (FanSpeedLimit) AttrLimitType(val LimitTypeAttr) attribute.KeyValue { return attribute.String("hw.limit_type", string(val)) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (FanSpeedLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (FanSpeedLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (FanSpeedLimit) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) } // FanSpeedRatio is an instrument used to record metric values conforming to the // "hw.fan.speed_ratio" semantic conventions. It represents the fan speed // expressed as a fraction of its maximum speed. type FanSpeedRatio struct { metric.Int64Gauge } var newFanSpeedRatioOpts = []metric.Int64GaugeOption{ metric.WithDescription("Fan speed expressed as a fraction of its maximum speed."), metric.WithUnit("1"), } // NewFanSpeedRatio returns a new FanSpeedRatio instrument. func NewFanSpeedRatio( m metric.Meter, opt ...metric.Int64GaugeOption, ) (FanSpeedRatio, error) { // Check if the meter is nil. if m == nil { return FanSpeedRatio{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newFanSpeedRatioOpts } else { opt = append(opt, newFanSpeedRatioOpts...) } i, err := m.Int64Gauge( "hw.fan.speed_ratio", opt..., ) if err != nil { return FanSpeedRatio{noop.Int64Gauge{}}, err } return FanSpeedRatio{i}, nil } // Inst returns the underlying metric instrument. func (m FanSpeedRatio) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (FanSpeedRatio) Name() string { return "hw.fan.speed_ratio" } // Unit returns the semantic convention unit of the instrument func (FanSpeedRatio) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (FanSpeedRatio) Description() string { return "Fan speed expressed as a fraction of its maximum speed." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m FanSpeedRatio) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m FanSpeedRatio) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (FanSpeedRatio) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (FanSpeedRatio) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (FanSpeedRatio) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) } // GpuIO is an instrument used to record metric values conforming to the // "hw.gpu.io" semantic conventions. It represents the received and transmitted // bytes by the GPU. type GpuIO struct { metric.Int64Counter } var newGpuIOOpts = []metric.Int64CounterOption{ metric.WithDescription("Received and transmitted bytes by the GPU."), metric.WithUnit("By"), } // NewGpuIO returns a new GpuIO instrument. func NewGpuIO( m metric.Meter, opt ...metric.Int64CounterOption, ) (GpuIO, error) { // Check if the meter is nil. if m == nil { return GpuIO{noop.Int64Counter{}}, nil } if len(opt) == 0 { opt = newGpuIOOpts } else { opt = append(opt, newGpuIOOpts...) } i, err := m.Int64Counter( "hw.gpu.io", opt..., ) if err != nil { return GpuIO{noop.Int64Counter{}}, err } return GpuIO{i}, nil } // Inst returns the underlying metric instrument. func (m GpuIO) Inst() metric.Int64Counter { return m.Int64Counter } // Name returns the semantic convention name of the instrument. func (GpuIO) Name() string { return "hw.gpu.io" } // Unit returns the semantic convention unit of the instrument func (GpuIO) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (GpuIO) Description() string { return "Received and transmitted bytes by the GPU." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The networkIoDirection is the the network IO operation direction. // // All additional attrs passed are included in the recorded value. func (m GpuIO) Add( ctx context.Context, incr int64, id string, networkIoDirection NetworkIODirectionAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("network.io.direction", string(networkIoDirection)), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("network.io.direction", string(networkIoDirection)), )..., ), ) m.Int64Counter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m GpuIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64Counter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Counter.Add(ctx, incr, *o...) } // AttrDriverVersion returns an optional attribute for the "hw.driver_version" // semantic convention. It represents the driver version for the hardware // component. func (GpuIO) AttrDriverVersion(val string) attribute.KeyValue { return attribute.String("hw.driver_version", val) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (GpuIO) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (GpuIO) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (GpuIO) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (GpuIO) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (GpuIO) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (GpuIO) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // GpuMemoryLimit is an instrument used to record metric values conforming to the // "hw.gpu.memory.limit" semantic conventions. It represents the size of the GPU // memory. type GpuMemoryLimit struct { metric.Int64UpDownCounter } var newGpuMemoryLimitOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Size of the GPU memory."), metric.WithUnit("By"), } // NewGpuMemoryLimit returns a new GpuMemoryLimit instrument. func NewGpuMemoryLimit( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (GpuMemoryLimit, error) { // Check if the meter is nil. if m == nil { return GpuMemoryLimit{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newGpuMemoryLimitOpts } else { opt = append(opt, newGpuMemoryLimitOpts...) } i, err := m.Int64UpDownCounter( "hw.gpu.memory.limit", opt..., ) if err != nil { return GpuMemoryLimit{noop.Int64UpDownCounter{}}, err } return GpuMemoryLimit{i}, nil } // Inst returns the underlying metric instrument. func (m GpuMemoryLimit) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (GpuMemoryLimit) Name() string { return "hw.gpu.memory.limit" } // Unit returns the semantic convention unit of the instrument func (GpuMemoryLimit) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (GpuMemoryLimit) Description() string { return "Size of the GPU memory." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m GpuMemoryLimit) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m GpuMemoryLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrDriverVersion returns an optional attribute for the "hw.driver_version" // semantic convention. It represents the driver version for the hardware // component. func (GpuMemoryLimit) AttrDriverVersion(val string) attribute.KeyValue { return attribute.String("hw.driver_version", val) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (GpuMemoryLimit) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (GpuMemoryLimit) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (GpuMemoryLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (GpuMemoryLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (GpuMemoryLimit) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (GpuMemoryLimit) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // GpuMemoryUsage is an instrument used to record metric values conforming to the // "hw.gpu.memory.usage" semantic conventions. It represents the GPU memory used. type GpuMemoryUsage struct { metric.Int64UpDownCounter } var newGpuMemoryUsageOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("GPU memory used."), metric.WithUnit("By"), } // NewGpuMemoryUsage returns a new GpuMemoryUsage instrument. func NewGpuMemoryUsage( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (GpuMemoryUsage, error) { // Check if the meter is nil. if m == nil { return GpuMemoryUsage{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newGpuMemoryUsageOpts } else { opt = append(opt, newGpuMemoryUsageOpts...) } i, err := m.Int64UpDownCounter( "hw.gpu.memory.usage", opt..., ) if err != nil { return GpuMemoryUsage{noop.Int64UpDownCounter{}}, err } return GpuMemoryUsage{i}, nil } // Inst returns the underlying metric instrument. func (m GpuMemoryUsage) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (GpuMemoryUsage) Name() string { return "hw.gpu.memory.usage" } // Unit returns the semantic convention unit of the instrument func (GpuMemoryUsage) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (GpuMemoryUsage) Description() string { return "GPU memory used." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m GpuMemoryUsage) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m GpuMemoryUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrDriverVersion returns an optional attribute for the "hw.driver_version" // semantic convention. It represents the driver version for the hardware // component. func (GpuMemoryUsage) AttrDriverVersion(val string) attribute.KeyValue { return attribute.String("hw.driver_version", val) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (GpuMemoryUsage) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (GpuMemoryUsage) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (GpuMemoryUsage) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (GpuMemoryUsage) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (GpuMemoryUsage) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (GpuMemoryUsage) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // GpuMemoryUtilization is an instrument used to record metric values conforming // to the "hw.gpu.memory.utilization" semantic conventions. It represents the // fraction of GPU memory used. type GpuMemoryUtilization struct { metric.Int64Gauge } var newGpuMemoryUtilizationOpts = []metric.Int64GaugeOption{ metric.WithDescription("Fraction of GPU memory used."), metric.WithUnit("1"), } // NewGpuMemoryUtilization returns a new GpuMemoryUtilization instrument. func NewGpuMemoryUtilization( m metric.Meter, opt ...metric.Int64GaugeOption, ) (GpuMemoryUtilization, error) { // Check if the meter is nil. if m == nil { return GpuMemoryUtilization{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newGpuMemoryUtilizationOpts } else { opt = append(opt, newGpuMemoryUtilizationOpts...) } i, err := m.Int64Gauge( "hw.gpu.memory.utilization", opt..., ) if err != nil { return GpuMemoryUtilization{noop.Int64Gauge{}}, err } return GpuMemoryUtilization{i}, nil } // Inst returns the underlying metric instrument. func (m GpuMemoryUtilization) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (GpuMemoryUtilization) Name() string { return "hw.gpu.memory.utilization" } // Unit returns the semantic convention unit of the instrument func (GpuMemoryUtilization) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (GpuMemoryUtilization) Description() string { return "Fraction of GPU memory used." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m GpuMemoryUtilization) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m GpuMemoryUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrDriverVersion returns an optional attribute for the "hw.driver_version" // semantic convention. It represents the driver version for the hardware // component. func (GpuMemoryUtilization) AttrDriverVersion(val string) attribute.KeyValue { return attribute.String("hw.driver_version", val) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (GpuMemoryUtilization) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (GpuMemoryUtilization) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (GpuMemoryUtilization) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (GpuMemoryUtilization) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (GpuMemoryUtilization) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (GpuMemoryUtilization) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // GpuUtilization is an instrument used to record metric values conforming to the // "hw.gpu.utilization" semantic conventions. It represents the fraction of time // spent in a specific task. type GpuUtilization struct { metric.Int64Gauge } var newGpuUtilizationOpts = []metric.Int64GaugeOption{ metric.WithDescription("Fraction of time spent in a specific task."), metric.WithUnit("1"), } // NewGpuUtilization returns a new GpuUtilization instrument. func NewGpuUtilization( m metric.Meter, opt ...metric.Int64GaugeOption, ) (GpuUtilization, error) { // Check if the meter is nil. if m == nil { return GpuUtilization{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newGpuUtilizationOpts } else { opt = append(opt, newGpuUtilizationOpts...) } i, err := m.Int64Gauge( "hw.gpu.utilization", opt..., ) if err != nil { return GpuUtilization{noop.Int64Gauge{}}, err } return GpuUtilization{i}, nil } // Inst returns the underlying metric instrument. func (m GpuUtilization) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (GpuUtilization) Name() string { return "hw.gpu.utilization" } // Unit returns the semantic convention unit of the instrument func (GpuUtilization) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (GpuUtilization) Description() string { return "Fraction of time spent in a specific task." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m GpuUtilization) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m GpuUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrDriverVersion returns an optional attribute for the "hw.driver_version" // semantic convention. It represents the driver version for the hardware // component. func (GpuUtilization) AttrDriverVersion(val string) attribute.KeyValue { return attribute.String("hw.driver_version", val) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (GpuUtilization) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrGpuTask returns an optional attribute for the "hw.gpu.task" semantic // convention. It represents the type of task the GPU is performing. func (GpuUtilization) AttrGpuTask(val GpuTaskAttr) attribute.KeyValue { return attribute.String("hw.gpu.task", string(val)) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (GpuUtilization) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (GpuUtilization) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (GpuUtilization) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (GpuUtilization) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (GpuUtilization) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // HostAmbientTemperature is an instrument used to record metric values // conforming to the "hw.host.ambient_temperature" semantic conventions. It // represents the ambient (external) temperature of the physical host. type HostAmbientTemperature struct { metric.Int64Gauge } var newHostAmbientTemperatureOpts = []metric.Int64GaugeOption{ metric.WithDescription("Ambient (external) temperature of the physical host."), metric.WithUnit("Cel"), } // NewHostAmbientTemperature returns a new HostAmbientTemperature instrument. func NewHostAmbientTemperature( m metric.Meter, opt ...metric.Int64GaugeOption, ) (HostAmbientTemperature, error) { // Check if the meter is nil. if m == nil { return HostAmbientTemperature{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newHostAmbientTemperatureOpts } else { opt = append(opt, newHostAmbientTemperatureOpts...) } i, err := m.Int64Gauge( "hw.host.ambient_temperature", opt..., ) if err != nil { return HostAmbientTemperature{noop.Int64Gauge{}}, err } return HostAmbientTemperature{i}, nil } // Inst returns the underlying metric instrument. func (m HostAmbientTemperature) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (HostAmbientTemperature) Name() string { return "hw.host.ambient_temperature" } // Unit returns the semantic convention unit of the instrument func (HostAmbientTemperature) Unit() string { return "Cel" } // Description returns the semantic convention description of the instrument func (HostAmbientTemperature) Description() string { return "Ambient (external) temperature of the physical host." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m HostAmbientTemperature) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m HostAmbientTemperature) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostAmbientTemperature) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (HostAmbientTemperature) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // HostEnergy is an instrument used to record metric values conforming to the // "hw.host.energy" semantic conventions. It represents the total energy consumed // by the entire physical host, in joules. type HostEnergy struct { metric.Int64Counter } var newHostEnergyOpts = []metric.Int64CounterOption{ metric.WithDescription("Total energy consumed by the entire physical host, in joules."), metric.WithUnit("J"), } // NewHostEnergy returns a new HostEnergy instrument. func NewHostEnergy( m metric.Meter, opt ...metric.Int64CounterOption, ) (HostEnergy, error) { // Check if the meter is nil. if m == nil { return HostEnergy{noop.Int64Counter{}}, nil } if len(opt) == 0 { opt = newHostEnergyOpts } else { opt = append(opt, newHostEnergyOpts...) } i, err := m.Int64Counter( "hw.host.energy", opt..., ) if err != nil { return HostEnergy{noop.Int64Counter{}}, err } return HostEnergy{i}, nil } // Inst returns the underlying metric instrument. func (m HostEnergy) Inst() metric.Int64Counter { return m.Int64Counter } // Name returns the semantic convention name of the instrument. func (HostEnergy) Name() string { return "hw.host.energy" } // Unit returns the semantic convention unit of the instrument func (HostEnergy) Unit() string { return "J" } // Description returns the semantic convention description of the instrument func (HostEnergy) Description() string { return "Total energy consumed by the entire physical host, in joules." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. // // The overall energy usage of a host MUST be reported using the specific // `hw.host.energy` and `hw.host.power` metrics **only**, instead of the generic // `hw.energy` and `hw.power` described in the previous section, to prevent // summing up overlapping values. func (m HostEnergy) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Counter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. // // The overall energy usage of a host MUST be reported using the specific // `hw.host.energy` and `hw.host.power` metrics **only**, instead of the generic // `hw.energy` and `hw.power` described in the previous section, to prevent // summing up overlapping values. func (m HostEnergy) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64Counter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Counter.Add(ctx, incr, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostEnergy) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (HostEnergy) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // HostHeatingMargin is an instrument used to record metric values conforming to // the "hw.host.heating_margin" semantic conventions. It represents the by how // many degrees Celsius the temperature of the physical host can be increased, // before reaching a warning threshold on one of the internal sensors. type HostHeatingMargin struct { metric.Int64Gauge } var newHostHeatingMarginOpts = []metric.Int64GaugeOption{ metric.WithDescription("By how many degrees Celsius the temperature of the physical host can be increased, before reaching a warning threshold on one of the internal sensors."), metric.WithUnit("Cel"), } // NewHostHeatingMargin returns a new HostHeatingMargin instrument. func NewHostHeatingMargin( m metric.Meter, opt ...metric.Int64GaugeOption, ) (HostHeatingMargin, error) { // Check if the meter is nil. if m == nil { return HostHeatingMargin{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newHostHeatingMarginOpts } else { opt = append(opt, newHostHeatingMarginOpts...) } i, err := m.Int64Gauge( "hw.host.heating_margin", opt..., ) if err != nil { return HostHeatingMargin{noop.Int64Gauge{}}, err } return HostHeatingMargin{i}, nil } // Inst returns the underlying metric instrument. func (m HostHeatingMargin) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (HostHeatingMargin) Name() string { return "hw.host.heating_margin" } // Unit returns the semantic convention unit of the instrument func (HostHeatingMargin) Unit() string { return "Cel" } // Description returns the semantic convention description of the instrument func (HostHeatingMargin) Description() string { return "By how many degrees Celsius the temperature of the physical host can be increased, before reaching a warning threshold on one of the internal sensors." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m HostHeatingMargin) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m HostHeatingMargin) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostHeatingMargin) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (HostHeatingMargin) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // HostPower is an instrument used to record metric values conforming to the // "hw.host.power" semantic conventions. It represents the instantaneous power // consumed by the entire physical host in Watts (`hw.host.energy` is preferred). type HostPower struct { metric.Int64Gauge } var newHostPowerOpts = []metric.Int64GaugeOption{ metric.WithDescription("Instantaneous power consumed by the entire physical host in Watts (`hw.host.energy` is preferred)."), metric.WithUnit("W"), } // NewHostPower returns a new HostPower instrument. func NewHostPower( m metric.Meter, opt ...metric.Int64GaugeOption, ) (HostPower, error) { // Check if the meter is nil. if m == nil { return HostPower{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newHostPowerOpts } else { opt = append(opt, newHostPowerOpts...) } i, err := m.Int64Gauge( "hw.host.power", opt..., ) if err != nil { return HostPower{noop.Int64Gauge{}}, err } return HostPower{i}, nil } // Inst returns the underlying metric instrument. func (m HostPower) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (HostPower) Name() string { return "hw.host.power" } // Unit returns the semantic convention unit of the instrument func (HostPower) Unit() string { return "W" } // Description returns the semantic convention description of the instrument func (HostPower) Description() string { return "Instantaneous power consumed by the entire physical host in Watts (`hw.host.energy` is preferred)." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. // // The overall energy usage of a host MUST be reported using the specific // `hw.host.energy` and `hw.host.power` metrics **only**, instead of the generic // `hw.energy` and `hw.power` described in the previous section, to prevent // summing up overlapping values. func (m HostPower) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. // // The overall energy usage of a host MUST be reported using the specific // `hw.host.energy` and `hw.host.power` metrics **only**, instead of the generic // `hw.energy` and `hw.power` described in the previous section, to prevent // summing up overlapping values. func (m HostPower) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (HostPower) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (HostPower) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // LogicalDiskLimit is an instrument used to record metric values conforming to // the "hw.logical_disk.limit" semantic conventions. It represents the size of // the logical disk. type LogicalDiskLimit struct { metric.Int64UpDownCounter } var newLogicalDiskLimitOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Size of the logical disk."), metric.WithUnit("By"), } // NewLogicalDiskLimit returns a new LogicalDiskLimit instrument. func NewLogicalDiskLimit( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (LogicalDiskLimit, error) { // Check if the meter is nil. if m == nil { return LogicalDiskLimit{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newLogicalDiskLimitOpts } else { opt = append(opt, newLogicalDiskLimitOpts...) } i, err := m.Int64UpDownCounter( "hw.logical_disk.limit", opt..., ) if err != nil { return LogicalDiskLimit{noop.Int64UpDownCounter{}}, err } return LogicalDiskLimit{i}, nil } // Inst returns the underlying metric instrument. func (m LogicalDiskLimit) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (LogicalDiskLimit) Name() string { return "hw.logical_disk.limit" } // Unit returns the semantic convention unit of the instrument func (LogicalDiskLimit) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (LogicalDiskLimit) Description() string { return "Size of the logical disk." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m LogicalDiskLimit) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m LogicalDiskLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrLogicalDiskRaidLevel returns an optional attribute for the // "hw.logical_disk.raid_level" semantic convention. It represents the RAID Level // of the logical disk. func (LogicalDiskLimit) AttrLogicalDiskRaidLevel(val string) attribute.KeyValue { return attribute.String("hw.logical_disk.raid_level", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (LogicalDiskLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (LogicalDiskLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // LogicalDiskUsage is an instrument used to record metric values conforming to // the "hw.logical_disk.usage" semantic conventions. It represents the logical // disk space usage. type LogicalDiskUsage struct { metric.Int64UpDownCounter } var newLogicalDiskUsageOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Logical disk space usage."), metric.WithUnit("By"), } // NewLogicalDiskUsage returns a new LogicalDiskUsage instrument. func NewLogicalDiskUsage( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (LogicalDiskUsage, error) { // Check if the meter is nil. if m == nil { return LogicalDiskUsage{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newLogicalDiskUsageOpts } else { opt = append(opt, newLogicalDiskUsageOpts...) } i, err := m.Int64UpDownCounter( "hw.logical_disk.usage", opt..., ) if err != nil { return LogicalDiskUsage{noop.Int64UpDownCounter{}}, err } return LogicalDiskUsage{i}, nil } // Inst returns the underlying metric instrument. func (m LogicalDiskUsage) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (LogicalDiskUsage) Name() string { return "hw.logical_disk.usage" } // Unit returns the semantic convention unit of the instrument func (LogicalDiskUsage) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (LogicalDiskUsage) Description() string { return "Logical disk space usage." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The logicalDiskState is the state of the logical disk space usage // // All additional attrs passed are included in the recorded value. func (m LogicalDiskUsage) Add( ctx context.Context, incr int64, id string, logicalDiskState LogicalDiskStateAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.logical_disk.state", string(logicalDiskState)), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.logical_disk.state", string(logicalDiskState)), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m LogicalDiskUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrLogicalDiskRaidLevel returns an optional attribute for the // "hw.logical_disk.raid_level" semantic convention. It represents the RAID Level // of the logical disk. func (LogicalDiskUsage) AttrLogicalDiskRaidLevel(val string) attribute.KeyValue { return attribute.String("hw.logical_disk.raid_level", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (LogicalDiskUsage) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (LogicalDiskUsage) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // LogicalDiskUtilization is an instrument used to record metric values // conforming to the "hw.logical_disk.utilization" semantic conventions. It // represents the logical disk space utilization as a fraction. type LogicalDiskUtilization struct { metric.Int64Gauge } var newLogicalDiskUtilizationOpts = []metric.Int64GaugeOption{ metric.WithDescription("Logical disk space utilization as a fraction."), metric.WithUnit("1"), } // NewLogicalDiskUtilization returns a new LogicalDiskUtilization instrument. func NewLogicalDiskUtilization( m metric.Meter, opt ...metric.Int64GaugeOption, ) (LogicalDiskUtilization, error) { // Check if the meter is nil. if m == nil { return LogicalDiskUtilization{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newLogicalDiskUtilizationOpts } else { opt = append(opt, newLogicalDiskUtilizationOpts...) } i, err := m.Int64Gauge( "hw.logical_disk.utilization", opt..., ) if err != nil { return LogicalDiskUtilization{noop.Int64Gauge{}}, err } return LogicalDiskUtilization{i}, nil } // Inst returns the underlying metric instrument. func (m LogicalDiskUtilization) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (LogicalDiskUtilization) Name() string { return "hw.logical_disk.utilization" } // Unit returns the semantic convention unit of the instrument func (LogicalDiskUtilization) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (LogicalDiskUtilization) Description() string { return "Logical disk space utilization as a fraction." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The logicalDiskState is the state of the logical disk space usage // // All additional attrs passed are included in the recorded value. func (m LogicalDiskUtilization) Record( ctx context.Context, val int64, id string, logicalDiskState LogicalDiskStateAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.logical_disk.state", string(logicalDiskState)), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.logical_disk.state", string(logicalDiskState)), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m LogicalDiskUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrLogicalDiskRaidLevel returns an optional attribute for the // "hw.logical_disk.raid_level" semantic convention. It represents the RAID Level // of the logical disk. func (LogicalDiskUtilization) AttrLogicalDiskRaidLevel(val string) attribute.KeyValue { return attribute.String("hw.logical_disk.raid_level", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (LogicalDiskUtilization) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (LogicalDiskUtilization) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // MemorySize is an instrument used to record metric values conforming to the // "hw.memory.size" semantic conventions. It represents the size of the memory // module. type MemorySize struct { metric.Int64UpDownCounter } var newMemorySizeOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Size of the memory module."), metric.WithUnit("By"), } // NewMemorySize returns a new MemorySize instrument. func NewMemorySize( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (MemorySize, error) { // Check if the meter is nil. if m == nil { return MemorySize{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newMemorySizeOpts } else { opt = append(opt, newMemorySizeOpts...) } i, err := m.Int64UpDownCounter( "hw.memory.size", opt..., ) if err != nil { return MemorySize{noop.Int64UpDownCounter{}}, err } return MemorySize{i}, nil } // Inst returns the underlying metric instrument. func (m MemorySize) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (MemorySize) Name() string { return "hw.memory.size" } // Unit returns the semantic convention unit of the instrument func (MemorySize) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (MemorySize) Description() string { return "Size of the memory module." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m MemorySize) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m MemorySize) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrMemoryType returns an optional attribute for the "hw.memory.type" semantic // convention. It represents the type of the memory module. func (MemorySize) AttrMemoryType(val string) attribute.KeyValue { return attribute.String("hw.memory.type", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (MemorySize) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (MemorySize) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (MemorySize) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (MemorySize) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (MemorySize) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // NetworkBandwidthLimit is an instrument used to record metric values conforming // to the "hw.network.bandwidth.limit" semantic conventions. It represents the // link speed. type NetworkBandwidthLimit struct { metric.Int64UpDownCounter } var newNetworkBandwidthLimitOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Link speed."), metric.WithUnit("By/s"), } // NewNetworkBandwidthLimit returns a new NetworkBandwidthLimit instrument. func NewNetworkBandwidthLimit( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (NetworkBandwidthLimit, error) { // Check if the meter is nil. if m == nil { return NetworkBandwidthLimit{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newNetworkBandwidthLimitOpts } else { opt = append(opt, newNetworkBandwidthLimitOpts...) } i, err := m.Int64UpDownCounter( "hw.network.bandwidth.limit", opt..., ) if err != nil { return NetworkBandwidthLimit{noop.Int64UpDownCounter{}}, err } return NetworkBandwidthLimit{i}, nil } // Inst returns the underlying metric instrument. func (m NetworkBandwidthLimit) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (NetworkBandwidthLimit) Name() string { return "hw.network.bandwidth.limit" } // Unit returns the semantic convention unit of the instrument func (NetworkBandwidthLimit) Unit() string { return "By/s" } // Description returns the semantic convention description of the instrument func (NetworkBandwidthLimit) Description() string { return "Link speed." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m NetworkBandwidthLimit) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m NetworkBandwidthLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (NetworkBandwidthLimit) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (NetworkBandwidthLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrNetworkLogicalAddresses returns an optional attribute for the // "hw.network.logical_addresses" semantic convention. It represents the logical // addresses of the adapter (e.g. IP address, or WWPN). func (NetworkBandwidthLimit) AttrNetworkLogicalAddresses(val ...string) attribute.KeyValue { return attribute.StringSlice("hw.network.logical_addresses", val) } // AttrNetworkPhysicalAddress returns an optional attribute for the // "hw.network.physical_address" semantic convention. It represents the physical // address of the adapter (e.g. MAC address, or WWNN). func (NetworkBandwidthLimit) AttrNetworkPhysicalAddress(val string) attribute.KeyValue { return attribute.String("hw.network.physical_address", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (NetworkBandwidthLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (NetworkBandwidthLimit) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (NetworkBandwidthLimit) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // NetworkBandwidthUtilization is an instrument used to record metric values // conforming to the "hw.network.bandwidth.utilization" semantic conventions. It // represents the utilization of the network bandwidth as a fraction. type NetworkBandwidthUtilization struct { metric.Int64Gauge } var newNetworkBandwidthUtilizationOpts = []metric.Int64GaugeOption{ metric.WithDescription("Utilization of the network bandwidth as a fraction."), metric.WithUnit("1"), } // NewNetworkBandwidthUtilization returns a new NetworkBandwidthUtilization // instrument. func NewNetworkBandwidthUtilization( m metric.Meter, opt ...metric.Int64GaugeOption, ) (NetworkBandwidthUtilization, error) { // Check if the meter is nil. if m == nil { return NetworkBandwidthUtilization{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newNetworkBandwidthUtilizationOpts } else { opt = append(opt, newNetworkBandwidthUtilizationOpts...) } i, err := m.Int64Gauge( "hw.network.bandwidth.utilization", opt..., ) if err != nil { return NetworkBandwidthUtilization{noop.Int64Gauge{}}, err } return NetworkBandwidthUtilization{i}, nil } // Inst returns the underlying metric instrument. func (m NetworkBandwidthUtilization) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (NetworkBandwidthUtilization) Name() string { return "hw.network.bandwidth.utilization" } // Unit returns the semantic convention unit of the instrument func (NetworkBandwidthUtilization) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (NetworkBandwidthUtilization) Description() string { return "Utilization of the network bandwidth as a fraction." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m NetworkBandwidthUtilization) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m NetworkBandwidthUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (NetworkBandwidthUtilization) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (NetworkBandwidthUtilization) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrNetworkLogicalAddresses returns an optional attribute for the // "hw.network.logical_addresses" semantic convention. It represents the logical // addresses of the adapter (e.g. IP address, or WWPN). func (NetworkBandwidthUtilization) AttrNetworkLogicalAddresses(val ...string) attribute.KeyValue { return attribute.StringSlice("hw.network.logical_addresses", val) } // AttrNetworkPhysicalAddress returns an optional attribute for the // "hw.network.physical_address" semantic convention. It represents the physical // address of the adapter (e.g. MAC address, or WWNN). func (NetworkBandwidthUtilization) AttrNetworkPhysicalAddress(val string) attribute.KeyValue { return attribute.String("hw.network.physical_address", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (NetworkBandwidthUtilization) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (NetworkBandwidthUtilization) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (NetworkBandwidthUtilization) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // NetworkIO is an instrument used to record metric values conforming to the // "hw.network.io" semantic conventions. It represents the received and // transmitted network traffic in bytes. type NetworkIO struct { metric.Int64Counter } var newNetworkIOOpts = []metric.Int64CounterOption{ metric.WithDescription("Received and transmitted network traffic in bytes."), metric.WithUnit("By"), } // NewNetworkIO returns a new NetworkIO instrument. func NewNetworkIO( m metric.Meter, opt ...metric.Int64CounterOption, ) (NetworkIO, error) { // Check if the meter is nil. if m == nil { return NetworkIO{noop.Int64Counter{}}, nil } if len(opt) == 0 { opt = newNetworkIOOpts } else { opt = append(opt, newNetworkIOOpts...) } i, err := m.Int64Counter( "hw.network.io", opt..., ) if err != nil { return NetworkIO{noop.Int64Counter{}}, err } return NetworkIO{i}, nil } // Inst returns the underlying metric instrument. func (m NetworkIO) Inst() metric.Int64Counter { return m.Int64Counter } // Name returns the semantic convention name of the instrument. func (NetworkIO) Name() string { return "hw.network.io" } // Unit returns the semantic convention unit of the instrument func (NetworkIO) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (NetworkIO) Description() string { return "Received and transmitted network traffic in bytes." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The networkIoDirection is the the network IO operation direction. // // All additional attrs passed are included in the recorded value. func (m NetworkIO) Add( ctx context.Context, incr int64, id string, networkIoDirection NetworkIODirectionAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("network.io.direction", string(networkIoDirection)), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("network.io.direction", string(networkIoDirection)), )..., ), ) m.Int64Counter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m NetworkIO) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64Counter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Counter.Add(ctx, incr, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (NetworkIO) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (NetworkIO) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrNetworkLogicalAddresses returns an optional attribute for the // "hw.network.logical_addresses" semantic convention. It represents the logical // addresses of the adapter (e.g. IP address, or WWPN). func (NetworkIO) AttrNetworkLogicalAddresses(val ...string) attribute.KeyValue { return attribute.StringSlice("hw.network.logical_addresses", val) } // AttrNetworkPhysicalAddress returns an optional attribute for the // "hw.network.physical_address" semantic convention. It represents the physical // address of the adapter (e.g. MAC address, or WWNN). func (NetworkIO) AttrNetworkPhysicalAddress(val string) attribute.KeyValue { return attribute.String("hw.network.physical_address", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (NetworkIO) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (NetworkIO) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (NetworkIO) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // NetworkPackets is an instrument used to record metric values conforming to the // "hw.network.packets" semantic conventions. It represents the received and // transmitted network traffic in packets (or frames). type NetworkPackets struct { metric.Int64Counter } var newNetworkPacketsOpts = []metric.Int64CounterOption{ metric.WithDescription("Received and transmitted network traffic in packets (or frames)."), metric.WithUnit("{packet}"), } // NewNetworkPackets returns a new NetworkPackets instrument. func NewNetworkPackets( m metric.Meter, opt ...metric.Int64CounterOption, ) (NetworkPackets, error) { // Check if the meter is nil. if m == nil { return NetworkPackets{noop.Int64Counter{}}, nil } if len(opt) == 0 { opt = newNetworkPacketsOpts } else { opt = append(opt, newNetworkPacketsOpts...) } i, err := m.Int64Counter( "hw.network.packets", opt..., ) if err != nil { return NetworkPackets{noop.Int64Counter{}}, err } return NetworkPackets{i}, nil } // Inst returns the underlying metric instrument. func (m NetworkPackets) Inst() metric.Int64Counter { return m.Int64Counter } // Name returns the semantic convention name of the instrument. func (NetworkPackets) Name() string { return "hw.network.packets" } // Unit returns the semantic convention unit of the instrument func (NetworkPackets) Unit() string { return "{packet}" } // Description returns the semantic convention description of the instrument func (NetworkPackets) Description() string { return "Received and transmitted network traffic in packets (or frames)." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The networkIoDirection is the the network IO operation direction. // // All additional attrs passed are included in the recorded value. func (m NetworkPackets) Add( ctx context.Context, incr int64, id string, networkIoDirection NetworkIODirectionAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("network.io.direction", string(networkIoDirection)), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("network.io.direction", string(networkIoDirection)), )..., ), ) m.Int64Counter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m NetworkPackets) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64Counter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Counter.Add(ctx, incr, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (NetworkPackets) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (NetworkPackets) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrNetworkLogicalAddresses returns an optional attribute for the // "hw.network.logical_addresses" semantic convention. It represents the logical // addresses of the adapter (e.g. IP address, or WWPN). func (NetworkPackets) AttrNetworkLogicalAddresses(val ...string) attribute.KeyValue { return attribute.StringSlice("hw.network.logical_addresses", val) } // AttrNetworkPhysicalAddress returns an optional attribute for the // "hw.network.physical_address" semantic convention. It represents the physical // address of the adapter (e.g. MAC address, or WWNN). func (NetworkPackets) AttrNetworkPhysicalAddress(val string) attribute.KeyValue { return attribute.String("hw.network.physical_address", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (NetworkPackets) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (NetworkPackets) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (NetworkPackets) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // NetworkUp is an instrument used to record metric values conforming to the // "hw.network.up" semantic conventions. It represents the link status: `1` (up) // or `0` (down). type NetworkUp struct { metric.Int64UpDownCounter } var newNetworkUpOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Link status: `1` (up) or `0` (down)."), metric.WithUnit("1"), } // NewNetworkUp returns a new NetworkUp instrument. func NewNetworkUp( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (NetworkUp, error) { // Check if the meter is nil. if m == nil { return NetworkUp{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newNetworkUpOpts } else { opt = append(opt, newNetworkUpOpts...) } i, err := m.Int64UpDownCounter( "hw.network.up", opt..., ) if err != nil { return NetworkUp{noop.Int64UpDownCounter{}}, err } return NetworkUp{i}, nil } // Inst returns the underlying metric instrument. func (m NetworkUp) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (NetworkUp) Name() string { return "hw.network.up" } // Unit returns the semantic convention unit of the instrument func (NetworkUp) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (NetworkUp) Description() string { return "Link status: `1` (up) or `0` (down)." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m NetworkUp) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m NetworkUp) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (NetworkUp) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (NetworkUp) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrNetworkLogicalAddresses returns an optional attribute for the // "hw.network.logical_addresses" semantic convention. It represents the logical // addresses of the adapter (e.g. IP address, or WWPN). func (NetworkUp) AttrNetworkLogicalAddresses(val ...string) attribute.KeyValue { return attribute.StringSlice("hw.network.logical_addresses", val) } // AttrNetworkPhysicalAddress returns an optional attribute for the // "hw.network.physical_address" semantic convention. It represents the physical // address of the adapter (e.g. MAC address, or WWNN). func (NetworkUp) AttrNetworkPhysicalAddress(val string) attribute.KeyValue { return attribute.String("hw.network.physical_address", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (NetworkUp) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (NetworkUp) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (NetworkUp) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // PhysicalDiskEnduranceUtilization is an instrument used to record metric values // conforming to the "hw.physical_disk.endurance_utilization" semantic // conventions. It represents the endurance remaining for this SSD disk. type PhysicalDiskEnduranceUtilization struct { metric.Int64Gauge } var newPhysicalDiskEnduranceUtilizationOpts = []metric.Int64GaugeOption{ metric.WithDescription("Endurance remaining for this SSD disk."), metric.WithUnit("1"), } // NewPhysicalDiskEnduranceUtilization returns a new // PhysicalDiskEnduranceUtilization instrument. func NewPhysicalDiskEnduranceUtilization( m metric.Meter, opt ...metric.Int64GaugeOption, ) (PhysicalDiskEnduranceUtilization, error) { // Check if the meter is nil. if m == nil { return PhysicalDiskEnduranceUtilization{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newPhysicalDiskEnduranceUtilizationOpts } else { opt = append(opt, newPhysicalDiskEnduranceUtilizationOpts...) } i, err := m.Int64Gauge( "hw.physical_disk.endurance_utilization", opt..., ) if err != nil { return PhysicalDiskEnduranceUtilization{noop.Int64Gauge{}}, err } return PhysicalDiskEnduranceUtilization{i}, nil } // Inst returns the underlying metric instrument. func (m PhysicalDiskEnduranceUtilization) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (PhysicalDiskEnduranceUtilization) Name() string { return "hw.physical_disk.endurance_utilization" } // Unit returns the semantic convention unit of the instrument func (PhysicalDiskEnduranceUtilization) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (PhysicalDiskEnduranceUtilization) Description() string { return "Endurance remaining for this SSD disk." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The physicalDiskState is the state of the physical disk endurance utilization // // All additional attrs passed are included in the recorded value. func (m PhysicalDiskEnduranceUtilization) Record( ctx context.Context, val int64, id string, physicalDiskState PhysicalDiskStateAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.physical_disk.state", string(physicalDiskState)), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.physical_disk.state", string(physicalDiskState)), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m PhysicalDiskEnduranceUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (PhysicalDiskEnduranceUtilization) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (PhysicalDiskEnduranceUtilization) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (PhysicalDiskEnduranceUtilization) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (PhysicalDiskEnduranceUtilization) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrPhysicalDiskType returns an optional attribute for the // "hw.physical_disk.type" semantic convention. It represents the type of the // physical disk. func (PhysicalDiskEnduranceUtilization) AttrPhysicalDiskType(val string) attribute.KeyValue { return attribute.String("hw.physical_disk.type", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (PhysicalDiskEnduranceUtilization) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (PhysicalDiskEnduranceUtilization) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // PhysicalDiskSize is an instrument used to record metric values conforming to // the "hw.physical_disk.size" semantic conventions. It represents the size of // the disk. type PhysicalDiskSize struct { metric.Int64UpDownCounter } var newPhysicalDiskSizeOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Size of the disk."), metric.WithUnit("By"), } // NewPhysicalDiskSize returns a new PhysicalDiskSize instrument. func NewPhysicalDiskSize( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (PhysicalDiskSize, error) { // Check if the meter is nil. if m == nil { return PhysicalDiskSize{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newPhysicalDiskSizeOpts } else { opt = append(opt, newPhysicalDiskSizeOpts...) } i, err := m.Int64UpDownCounter( "hw.physical_disk.size", opt..., ) if err != nil { return PhysicalDiskSize{noop.Int64UpDownCounter{}}, err } return PhysicalDiskSize{i}, nil } // Inst returns the underlying metric instrument. func (m PhysicalDiskSize) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (PhysicalDiskSize) Name() string { return "hw.physical_disk.size" } // Unit returns the semantic convention unit of the instrument func (PhysicalDiskSize) Unit() string { return "By" } // Description returns the semantic convention description of the instrument func (PhysicalDiskSize) Description() string { return "Size of the disk." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m PhysicalDiskSize) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m PhysicalDiskSize) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (PhysicalDiskSize) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (PhysicalDiskSize) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (PhysicalDiskSize) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (PhysicalDiskSize) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrPhysicalDiskType returns an optional attribute for the // "hw.physical_disk.type" semantic convention. It represents the type of the // physical disk. func (PhysicalDiskSize) AttrPhysicalDiskType(val string) attribute.KeyValue { return attribute.String("hw.physical_disk.type", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (PhysicalDiskSize) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (PhysicalDiskSize) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // PhysicalDiskSmart is an instrument used to record metric values conforming to // the "hw.physical_disk.smart" semantic conventions. It represents the value of // the corresponding [S.M.A.R.T.] (Self-Monitoring, Analysis, and Reporting // Technology) attribute. // // [S.M.A.R.T.]: https://wikipedia.org/wiki/S.M.A.R.T. type PhysicalDiskSmart struct { metric.Int64Gauge } var newPhysicalDiskSmartOpts = []metric.Int64GaugeOption{ metric.WithDescription("Value of the corresponding [S.M.A.R.T.](https://wikipedia.org/wiki/S.M.A.R.T.) (Self-Monitoring, Analysis, and Reporting Technology) attribute."), metric.WithUnit("1"), } // NewPhysicalDiskSmart returns a new PhysicalDiskSmart instrument. func NewPhysicalDiskSmart( m metric.Meter, opt ...metric.Int64GaugeOption, ) (PhysicalDiskSmart, error) { // Check if the meter is nil. if m == nil { return PhysicalDiskSmart{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newPhysicalDiskSmartOpts } else { opt = append(opt, newPhysicalDiskSmartOpts...) } i, err := m.Int64Gauge( "hw.physical_disk.smart", opt..., ) if err != nil { return PhysicalDiskSmart{noop.Int64Gauge{}}, err } return PhysicalDiskSmart{i}, nil } // Inst returns the underlying metric instrument. func (m PhysicalDiskSmart) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (PhysicalDiskSmart) Name() string { return "hw.physical_disk.smart" } // Unit returns the semantic convention unit of the instrument func (PhysicalDiskSmart) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (PhysicalDiskSmart) Description() string { return "Value of the corresponding [S.M.A.R.T.](https://wikipedia.org/wiki/S.M.A.R.T.) (Self-Monitoring, Analysis, and Reporting Technology) attribute." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m PhysicalDiskSmart) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m PhysicalDiskSmart) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrFirmwareVersion returns an optional attribute for the // "hw.firmware_version" semantic convention. It represents the firmware version // of the hardware component. func (PhysicalDiskSmart) AttrFirmwareVersion(val string) attribute.KeyValue { return attribute.String("hw.firmware_version", val) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (PhysicalDiskSmart) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (PhysicalDiskSmart) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (PhysicalDiskSmart) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrPhysicalDiskSmartAttribute returns an optional attribute for the // "hw.physical_disk.smart_attribute" semantic convention. It represents the // [S.M.A.R.T.] (Self-Monitoring, Analysis, and Reporting Technology) attribute // of the physical disk. // // [S.M.A.R.T.]: https://wikipedia.org/wiki/S.M.A.R.T. func (PhysicalDiskSmart) AttrPhysicalDiskSmartAttribute(val string) attribute.KeyValue { return attribute.String("hw.physical_disk.smart_attribute", val) } // AttrPhysicalDiskType returns an optional attribute for the // "hw.physical_disk.type" semantic convention. It represents the type of the // physical disk. func (PhysicalDiskSmart) AttrPhysicalDiskType(val string) attribute.KeyValue { return attribute.String("hw.physical_disk.type", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (PhysicalDiskSmart) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (PhysicalDiskSmart) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // Power is an instrument used to record metric values conforming to the // "hw.power" semantic conventions. It represents the instantaneous power // consumed by the component. type Power struct { metric.Int64Gauge } var newPowerOpts = []metric.Int64GaugeOption{ metric.WithDescription("Instantaneous power consumed by the component."), metric.WithUnit("W"), } // NewPower returns a new Power instrument. func NewPower( m metric.Meter, opt ...metric.Int64GaugeOption, ) (Power, error) { // Check if the meter is nil. if m == nil { return Power{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newPowerOpts } else { opt = append(opt, newPowerOpts...) } i, err := m.Int64Gauge( "hw.power", opt..., ) if err != nil { return Power{noop.Int64Gauge{}}, err } return Power{i}, nil } // Inst returns the underlying metric instrument. func (m Power) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (Power) Name() string { return "hw.power" } // Unit returns the semantic convention unit of the instrument func (Power) Unit() string { return "W" } // Description returns the semantic convention description of the instrument func (Power) Description() string { return "Instantaneous power consumed by the component." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The hwType is the type of the component // // All additional attrs passed are included in the recorded value. // // It is recommended to report `hw.energy` instead of `hw.power` when possible. func (m Power) Record( ctx context.Context, val int64, id string, hwType TypeAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.type", string(hwType)), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.type", string(hwType)), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. // // It is recommended to report `hw.energy` instead of `hw.power` when possible. func (m Power) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Power) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (Power) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // PowerSupplyLimit is an instrument used to record metric values conforming to // the "hw.power_supply.limit" semantic conventions. It represents the maximum // power output of the power supply. type PowerSupplyLimit struct { metric.Int64UpDownCounter } var newPowerSupplyLimitOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Maximum power output of the power supply."), metric.WithUnit("W"), } // NewPowerSupplyLimit returns a new PowerSupplyLimit instrument. func NewPowerSupplyLimit( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (PowerSupplyLimit, error) { // Check if the meter is nil. if m == nil { return PowerSupplyLimit{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newPowerSupplyLimitOpts } else { opt = append(opt, newPowerSupplyLimitOpts...) } i, err := m.Int64UpDownCounter( "hw.power_supply.limit", opt..., ) if err != nil { return PowerSupplyLimit{noop.Int64UpDownCounter{}}, err } return PowerSupplyLimit{i}, nil } // Inst returns the underlying metric instrument. func (m PowerSupplyLimit) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (PowerSupplyLimit) Name() string { return "hw.power_supply.limit" } // Unit returns the semantic convention unit of the instrument func (PowerSupplyLimit) Unit() string { return "W" } // Description returns the semantic convention description of the instrument func (PowerSupplyLimit) Description() string { return "Maximum power output of the power supply." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m PowerSupplyLimit) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m PowerSupplyLimit) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrLimitType returns an optional attribute for the "hw.limit_type" semantic // convention. It represents the type of limit for hardware components. func (PowerSupplyLimit) AttrLimitType(val LimitTypeAttr) attribute.KeyValue { return attribute.String("hw.limit_type", string(val)) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (PowerSupplyLimit) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (PowerSupplyLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (PowerSupplyLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (PowerSupplyLimit) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (PowerSupplyLimit) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // PowerSupplyUsage is an instrument used to record metric values conforming to // the "hw.power_supply.usage" semantic conventions. It represents the current // power output of the power supply. type PowerSupplyUsage struct { metric.Int64UpDownCounter } var newPowerSupplyUsageOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Current power output of the power supply."), metric.WithUnit("W"), } // NewPowerSupplyUsage returns a new PowerSupplyUsage instrument. func NewPowerSupplyUsage( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (PowerSupplyUsage, error) { // Check if the meter is nil. if m == nil { return PowerSupplyUsage{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newPowerSupplyUsageOpts } else { opt = append(opt, newPowerSupplyUsageOpts...) } i, err := m.Int64UpDownCounter( "hw.power_supply.usage", opt..., ) if err != nil { return PowerSupplyUsage{noop.Int64UpDownCounter{}}, err } return PowerSupplyUsage{i}, nil } // Inst returns the underlying metric instrument. func (m PowerSupplyUsage) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (PowerSupplyUsage) Name() string { return "hw.power_supply.usage" } // Unit returns the semantic convention unit of the instrument func (PowerSupplyUsage) Unit() string { return "W" } // Description returns the semantic convention description of the instrument func (PowerSupplyUsage) Description() string { return "Current power output of the power supply." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m PowerSupplyUsage) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m PowerSupplyUsage) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (PowerSupplyUsage) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (PowerSupplyUsage) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (PowerSupplyUsage) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (PowerSupplyUsage) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (PowerSupplyUsage) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // PowerSupplyUtilization is an instrument used to record metric values // conforming to the "hw.power_supply.utilization" semantic conventions. It // represents the utilization of the power supply as a fraction of its maximum // output. type PowerSupplyUtilization struct { metric.Int64Gauge } var newPowerSupplyUtilizationOpts = []metric.Int64GaugeOption{ metric.WithDescription("Utilization of the power supply as a fraction of its maximum output."), metric.WithUnit("1"), } // NewPowerSupplyUtilization returns a new PowerSupplyUtilization instrument. func NewPowerSupplyUtilization( m metric.Meter, opt ...metric.Int64GaugeOption, ) (PowerSupplyUtilization, error) { // Check if the meter is nil. if m == nil { return PowerSupplyUtilization{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newPowerSupplyUtilizationOpts } else { opt = append(opt, newPowerSupplyUtilizationOpts...) } i, err := m.Int64Gauge( "hw.power_supply.utilization", opt..., ) if err != nil { return PowerSupplyUtilization{noop.Int64Gauge{}}, err } return PowerSupplyUtilization{i}, nil } // Inst returns the underlying metric instrument. func (m PowerSupplyUtilization) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (PowerSupplyUtilization) Name() string { return "hw.power_supply.utilization" } // Unit returns the semantic convention unit of the instrument func (PowerSupplyUtilization) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (PowerSupplyUtilization) Description() string { return "Utilization of the power supply as a fraction of its maximum output." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m PowerSupplyUtilization) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m PowerSupplyUtilization) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (PowerSupplyUtilization) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (PowerSupplyUtilization) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (PowerSupplyUtilization) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (PowerSupplyUtilization) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (PowerSupplyUtilization) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // Status is an instrument used to record metric values conforming to the // "hw.status" semantic conventions. It represents the operational status: `1` // (true) or `0` (false) for each of the possible states. type Status struct { metric.Int64UpDownCounter } var newStatusOpts = []metric.Int64UpDownCounterOption{ metric.WithDescription("Operational status: `1` (true) or `0` (false) for each of the possible states."), metric.WithUnit("1"), } // NewStatus returns a new Status instrument. func NewStatus( m metric.Meter, opt ...metric.Int64UpDownCounterOption, ) (Status, error) { // Check if the meter is nil. if m == nil { return Status{noop.Int64UpDownCounter{}}, nil } if len(opt) == 0 { opt = newStatusOpts } else { opt = append(opt, newStatusOpts...) } i, err := m.Int64UpDownCounter( "hw.status", opt..., ) if err != nil { return Status{noop.Int64UpDownCounter{}}, err } return Status{i}, nil } // Inst returns the underlying metric instrument. func (m Status) Inst() metric.Int64UpDownCounter { return m.Int64UpDownCounter } // Name returns the semantic convention name of the instrument. func (Status) Name() string { return "hw.status" } // Unit returns the semantic convention unit of the instrument func (Status) Unit() string { return "1" } // Description returns the semantic convention description of the instrument func (Status) Description() string { return "Operational status: `1` (true) or `0` (false) for each of the possible states." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // The state is the the current state of the component // // The hwType is the type of the component // // All additional attrs passed are included in the recorded value. // // `hw.status` is currently specified as an *UpDownCounter* but would ideally be // represented using a [*StateSet* as defined in OpenMetrics]. This semantic // convention will be updated once *StateSet* is specified in OpenTelemetry. This // planned change is not expected to have any consequence on the way users query // their timeseries backend to retrieve the values of `hw.status` over time. // // [ [*StateSet* as defined in OpenMetrics]: https://github.com/prometheus/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#stateset func (m Status) Add( ctx context.Context, incr int64, id string, state StateAttr, hwType TypeAttr, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), attribute.String("hw.state", string(state)), attribute.String("hw.type", string(hwType)), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), attribute.String("hw.state", string(state)), attribute.String("hw.type", string(hwType)), )..., ), ) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. // // `hw.status` is currently specified as an *UpDownCounter* but would ideally be // represented using a [*StateSet* as defined in OpenMetrics]. This semantic // convention will be updated once *StateSet* is specified in OpenTelemetry. This // planned change is not expected to have any consequence on the way users query // their timeseries backend to retrieve the values of `hw.status` over time. // // [ [*StateSet* as defined in OpenMetrics]: https://github.com/prometheus/OpenMetrics/blob/v1.0.0/specification/OpenMetrics.md#stateset func (m Status) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64UpDownCounter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64UpDownCounter.Add(ctx, incr, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Status) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (Status) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // TapeDriveOperations is an instrument used to record metric values conforming // to the "hw.tape_drive.operations" semantic conventions. It represents the // operations performed by the tape drive. type TapeDriveOperations struct { metric.Int64Counter } var newTapeDriveOperationsOpts = []metric.Int64CounterOption{ metric.WithDescription("Operations performed by the tape drive."), metric.WithUnit("{operation}"), } // NewTapeDriveOperations returns a new TapeDriveOperations instrument. func NewTapeDriveOperations( m metric.Meter, opt ...metric.Int64CounterOption, ) (TapeDriveOperations, error) { // Check if the meter is nil. if m == nil { return TapeDriveOperations{noop.Int64Counter{}}, nil } if len(opt) == 0 { opt = newTapeDriveOperationsOpts } else { opt = append(opt, newTapeDriveOperationsOpts...) } i, err := m.Int64Counter( "hw.tape_drive.operations", opt..., ) if err != nil { return TapeDriveOperations{noop.Int64Counter{}}, err } return TapeDriveOperations{i}, nil } // Inst returns the underlying metric instrument. func (m TapeDriveOperations) Inst() metric.Int64Counter { return m.Int64Counter } // Name returns the semantic convention name of the instrument. func (TapeDriveOperations) Name() string { return "hw.tape_drive.operations" } // Unit returns the semantic convention unit of the instrument func (TapeDriveOperations) Unit() string { return "{operation}" } // Description returns the semantic convention description of the instrument func (TapeDriveOperations) Description() string { return "Operations performed by the tape drive." } // Add adds incr to the existing count for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m TapeDriveOperations) Add( ctx context.Context, incr int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Counter.Add(ctx, incr, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Counter.Add(ctx, incr, *o...) } // AddSet adds incr to the existing count for set. func (m TapeDriveOperations) AddSet(ctx context.Context, incr int64, set attribute.Set) { if set.Len() == 0 { m.Int64Counter.Add(ctx, incr) return } o := addOptPool.Get().(*[]metric.AddOption) defer func() { *o = (*o)[:0] addOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Counter.Add(ctx, incr, *o...) } // AttrModel returns an optional attribute for the "hw.model" semantic // convention. It represents the descriptive model name of the hardware // component. func (TapeDriveOperations) AttrModel(val string) attribute.KeyValue { return attribute.String("hw.model", val) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (TapeDriveOperations) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (TapeDriveOperations) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSerialNumber returns an optional attribute for the "hw.serial_number" // semantic convention. It represents the serial number of the hardware // component. func (TapeDriveOperations) AttrSerialNumber(val string) attribute.KeyValue { return attribute.String("hw.serial_number", val) } // AttrTapeDriveOperationType returns an optional attribute for the // "hw.tape_drive.operation_type" semantic convention. It represents the type of // tape drive operation. func (TapeDriveOperations) AttrTapeDriveOperationType(val TapeDriveOperationTypeAttr) attribute.KeyValue { return attribute.String("hw.tape_drive.operation_type", string(val)) } // AttrVendor returns an optional attribute for the "hw.vendor" semantic // convention. It represents the vendor name of the hardware component. func (TapeDriveOperations) AttrVendor(val string) attribute.KeyValue { return attribute.String("hw.vendor", val) } // Temperature is an instrument used to record metric values conforming to the // "hw.temperature" semantic conventions. It represents the temperature in // degrees Celsius. type Temperature struct { metric.Int64Gauge } var newTemperatureOpts = []metric.Int64GaugeOption{ metric.WithDescription("Temperature in degrees Celsius."), metric.WithUnit("Cel"), } // NewTemperature returns a new Temperature instrument. func NewTemperature( m metric.Meter, opt ...metric.Int64GaugeOption, ) (Temperature, error) { // Check if the meter is nil. if m == nil { return Temperature{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newTemperatureOpts } else { opt = append(opt, newTemperatureOpts...) } i, err := m.Int64Gauge( "hw.temperature", opt..., ) if err != nil { return Temperature{noop.Int64Gauge{}}, err } return Temperature{i}, nil } // Inst returns the underlying metric instrument. func (m Temperature) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (Temperature) Name() string { return "hw.temperature" } // Unit returns the semantic convention unit of the instrument func (Temperature) Unit() string { return "Cel" } // Description returns the semantic convention description of the instrument func (Temperature) Description() string { return "Temperature in degrees Celsius." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m Temperature) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m Temperature) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Temperature) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (Temperature) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (Temperature) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) } // TemperatureLimit is an instrument used to record metric values conforming to // the "hw.temperature.limit" semantic conventions. It represents the temperature // limit in degrees Celsius. type TemperatureLimit struct { metric.Int64Gauge } var newTemperatureLimitOpts = []metric.Int64GaugeOption{ metric.WithDescription("Temperature limit in degrees Celsius."), metric.WithUnit("Cel"), } // NewTemperatureLimit returns a new TemperatureLimit instrument. func NewTemperatureLimit( m metric.Meter, opt ...metric.Int64GaugeOption, ) (TemperatureLimit, error) { // Check if the meter is nil. if m == nil { return TemperatureLimit{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newTemperatureLimitOpts } else { opt = append(opt, newTemperatureLimitOpts...) } i, err := m.Int64Gauge( "hw.temperature.limit", opt..., ) if err != nil { return TemperatureLimit{noop.Int64Gauge{}}, err } return TemperatureLimit{i}, nil } // Inst returns the underlying metric instrument. func (m TemperatureLimit) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (TemperatureLimit) Name() string { return "hw.temperature.limit" } // Unit returns the semantic convention unit of the instrument func (TemperatureLimit) Unit() string { return "Cel" } // Description returns the semantic convention description of the instrument func (TemperatureLimit) Description() string { return "Temperature limit in degrees Celsius." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m TemperatureLimit) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m TemperatureLimit) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrLimitType returns an optional attribute for the "hw.limit_type" semantic // convention. It represents the type of limit for hardware components. func (TemperatureLimit) AttrLimitType(val LimitTypeAttr) attribute.KeyValue { return attribute.String("hw.limit_type", string(val)) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (TemperatureLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (TemperatureLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (TemperatureLimit) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) } // Voltage is an instrument used to record metric values conforming to the // "hw.voltage" semantic conventions. It represents the voltage measured by the // sensor. type Voltage struct { metric.Int64Gauge } var newVoltageOpts = []metric.Int64GaugeOption{ metric.WithDescription("Voltage measured by the sensor."), metric.WithUnit("V"), } // NewVoltage returns a new Voltage instrument. func NewVoltage( m metric.Meter, opt ...metric.Int64GaugeOption, ) (Voltage, error) { // Check if the meter is nil. if m == nil { return Voltage{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newVoltageOpts } else { opt = append(opt, newVoltageOpts...) } i, err := m.Int64Gauge( "hw.voltage", opt..., ) if err != nil { return Voltage{noop.Int64Gauge{}}, err } return Voltage{i}, nil } // Inst returns the underlying metric instrument. func (m Voltage) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (Voltage) Name() string { return "hw.voltage" } // Unit returns the semantic convention unit of the instrument func (Voltage) Unit() string { return "V" } // Description returns the semantic convention description of the instrument func (Voltage) Description() string { return "Voltage measured by the sensor." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m Voltage) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m Voltage) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (Voltage) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (Voltage) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (Voltage) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) } // VoltageLimit is an instrument used to record metric values conforming to the // "hw.voltage.limit" semantic conventions. It represents the voltage limit in // Volts. type VoltageLimit struct { metric.Int64Gauge } var newVoltageLimitOpts = []metric.Int64GaugeOption{ metric.WithDescription("Voltage limit in Volts."), metric.WithUnit("V"), } // NewVoltageLimit returns a new VoltageLimit instrument. func NewVoltageLimit( m metric.Meter, opt ...metric.Int64GaugeOption, ) (VoltageLimit, error) { // Check if the meter is nil. if m == nil { return VoltageLimit{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newVoltageLimitOpts } else { opt = append(opt, newVoltageLimitOpts...) } i, err := m.Int64Gauge( "hw.voltage.limit", opt..., ) if err != nil { return VoltageLimit{noop.Int64Gauge{}}, err } return VoltageLimit{i}, nil } // Inst returns the underlying metric instrument. func (m VoltageLimit) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (VoltageLimit) Name() string { return "hw.voltage.limit" } // Unit returns the semantic convention unit of the instrument func (VoltageLimit) Unit() string { return "V" } // Description returns the semantic convention description of the instrument func (VoltageLimit) Description() string { return "Voltage limit in Volts." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m VoltageLimit) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m VoltageLimit) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrLimitType returns an optional attribute for the "hw.limit_type" semantic // convention. It represents the type of limit for hardware components. func (VoltageLimit) AttrLimitType(val LimitTypeAttr) attribute.KeyValue { return attribute.String("hw.limit_type", string(val)) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (VoltageLimit) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (VoltageLimit) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (VoltageLimit) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) } // VoltageNominal is an instrument used to record metric values conforming to the // "hw.voltage.nominal" semantic conventions. It represents the nominal // (expected) voltage. type VoltageNominal struct { metric.Int64Gauge } var newVoltageNominalOpts = []metric.Int64GaugeOption{ metric.WithDescription("Nominal (expected) voltage."), metric.WithUnit("V"), } // NewVoltageNominal returns a new VoltageNominal instrument. func NewVoltageNominal( m metric.Meter, opt ...metric.Int64GaugeOption, ) (VoltageNominal, error) { // Check if the meter is nil. if m == nil { return VoltageNominal{noop.Int64Gauge{}}, nil } if len(opt) == 0 { opt = newVoltageNominalOpts } else { opt = append(opt, newVoltageNominalOpts...) } i, err := m.Int64Gauge( "hw.voltage.nominal", opt..., ) if err != nil { return VoltageNominal{noop.Int64Gauge{}}, err } return VoltageNominal{i}, nil } // Inst returns the underlying metric instrument. func (m VoltageNominal) Inst() metric.Int64Gauge { return m.Int64Gauge } // Name returns the semantic convention name of the instrument. func (VoltageNominal) Name() string { return "hw.voltage.nominal" } // Unit returns the semantic convention unit of the instrument func (VoltageNominal) Unit() string { return "V" } // Description returns the semantic convention description of the instrument func (VoltageNominal) Description() string { return "Nominal (expected) voltage." } // Record records val to the current distribution for attrs. // // The id is the an identifier for the hardware component, unique within the // monitored host // // All additional attrs passed are included in the recorded value. func (m VoltageNominal) Record( ctx context.Context, val int64, id string, attrs ...attribute.KeyValue, ) { if len(attrs) == 0 { m.Int64Gauge.Record(ctx, val, metric.WithAttributes( attribute.String("hw.id", id), )) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append( *o, metric.WithAttributes( append( attrs[:len(attrs):len(attrs)], attribute.String("hw.id", id), )..., ), ) m.Int64Gauge.Record(ctx, val, *o...) } // RecordSet records val to the current distribution for set. func (m VoltageNominal) RecordSet(ctx context.Context, val int64, set attribute.Set) { if set.Len() == 0 { m.Int64Gauge.Record(ctx, val) return } o := recOptPool.Get().(*[]metric.RecordOption) defer func() { *o = (*o)[:0] recOptPool.Put(o) }() *o = append(*o, metric.WithAttributeSet(set)) m.Int64Gauge.Record(ctx, val, *o...) } // AttrName returns an optional attribute for the "hw.name" semantic convention. // It represents an easily-recognizable name for the hardware component. func (VoltageNominal) AttrName(val string) attribute.KeyValue { return attribute.String("hw.name", val) } // AttrParent returns an optional attribute for the "hw.parent" semantic // convention. It represents the unique identifier of the parent component // (typically the `hw.id` attribute of the enclosure, or disk controller). func (VoltageNominal) AttrParent(val string) attribute.KeyValue { return attribute.String("hw.parent", val) } // AttrSensorLocation returns an optional attribute for the "hw.sensor_location" // semantic convention. It represents the location of the sensor. func (VoltageNominal) AttrSensorLocation(val string) attribute.KeyValue { return attribute.String("hw.sensor_location", val) }