515 lines
24 KiB
Go
515 lines
24 KiB
Go
package collector
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sort"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
log "github.com/sirupsen/logrus"
|
|
"lostak.dev/shelly-exporter/configuration"
|
|
"lostak.dev/shelly-exporter/shelly"
|
|
)
|
|
|
|
// These identifiers use the common Gen1 /status protocol. The generic gen1
|
|
// identifier is available for compatible devices not explicitly listed here.
|
|
var gen1Products = []string{
|
|
"gen1",
|
|
"plug", "plug_s",
|
|
"shelly_1", "shelly_1pm", "shelly_1l", "shelly_2", "shelly_2_5", "shelly_4pro", "shelly_uni",
|
|
"shelly_i3",
|
|
"shelly_button1", "shelly_trv",
|
|
"shelly_em", "shelly_3em",
|
|
"shelly_bulb", "shelly_bulb_rgbw", "shelly_duo", "shelly_vintage", "shelly_rgbw2", "shelly_dimmer",
|
|
"shelly_ht", "shelly_flood", "shelly_smoke", "shelly_door_window", "shelly_motion", "shelly_sense", "shelly_gas",
|
|
}
|
|
|
|
func init() {
|
|
for _, product := range gen1Products {
|
|
if err := RegisterProduct(product, newGen1Collector); err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
type gen1Collector struct {
|
|
base baseCollector
|
|
client shelly.StatusClient
|
|
descriptors map[string]*prometheus.Desc
|
|
}
|
|
|
|
func newGen1Collector(config configuration.DeviceConfiguration, client shelly.StatusClient) (prometheus.Collector, error) {
|
|
if client == nil {
|
|
return nil, fmt.Errorf("client for device %q cannot be nil", config.Name)
|
|
}
|
|
c := &gen1Collector{
|
|
base: newBaseCollector(config.Name, config.Product),
|
|
client: client,
|
|
descriptors: make(map[string]*prometheus.Desc),
|
|
}
|
|
c.registerDescriptors()
|
|
return c, nil
|
|
}
|
|
|
|
func (c *gen1Collector) registerDescriptors() {
|
|
c.add("device_info", "Static Shelly device information.", "product", "mac", "firmware")
|
|
c.add("wifi_info", "Shelly Wi-Fi network information.", "ssid", "ip")
|
|
c.add("wifi_connected", "Whether the Wi-Fi station is connected (1) or not (0).")
|
|
c.add("wifi_rssi_dbm", "Received Wi-Fi signal strength in dBm.")
|
|
c.add("cloud_enabled", "Whether Shelly Cloud is enabled (1) or not (0).")
|
|
c.add("cloud_connected", "Whether the device is connected to Shelly Cloud (1) or not (0).")
|
|
c.add("mqtt_connected", "Whether the device is connected to MQTT (1) or not (0).")
|
|
c.add("update_available", "Whether a firmware update is available (1) or not (0).")
|
|
c.add("update_info", "Shelly firmware update information.", "status", "current_version", "new_version")
|
|
c.add("status_serial", "Sequence number of the Shelly status response.")
|
|
c.add("ram_size_bytes", "Total device RAM in bytes.")
|
|
c.add("ram_free_bytes", "Free device RAM in bytes.")
|
|
c.add("filesystem_size_bytes", "Total device filesystem size in bytes.")
|
|
c.add("filesystem_free_bytes", "Free device filesystem space in bytes.")
|
|
c.add("filesystem_mounted", "Whether the device data filesystem is mounted (1) or not (0).")
|
|
c.add("uptime_seconds", "Device uptime in seconds.")
|
|
|
|
c.add("relay_on", "Whether the relay output is on (1) or off (0).", "index")
|
|
c.add("relay_has_timer", "Whether a relay timer is active (1) or not (0).", "index")
|
|
c.add("relay_timer_duration_seconds", "Configured duration of the active relay timer in seconds.", "index")
|
|
c.add("relay_timer_remaining_seconds", "Remaining duration of the active relay timer in seconds.", "index")
|
|
c.add("relay_overpower", "Whether relay overpower protection is active (1) or not (0).", "index")
|
|
c.add("relay_valid", "Whether the relay status is valid (1) or not (0).", "index")
|
|
|
|
c.add("input_on", "Logical input state (1 for on, 0 for off).", "index")
|
|
c.add("input_event_info", "Latest input event and event sequence.", "index", "event", "last_sequence")
|
|
c.add("input_event_count_total", "Total input events since the device restarted.", "index")
|
|
|
|
c.add("meter_power_watts", "Current active power measured in watts.", "index")
|
|
c.add("meter_valid", "Whether the meter reading is valid (1) or not (0).", "index")
|
|
c.add("meter_timestamp_seconds", "Unix timestamp of the meter reading in seconds.", "index")
|
|
c.add("meter_overpower", "Whether the meter reports an overpower condition (1) or not (0).", "index")
|
|
c.add("meter_overpower_threshold_watts", "Configured meter overpower threshold in watts.", "index")
|
|
c.add("meter_recent_energy_watt_minutes", "Recent per-minute energy reported in watt-minutes.", "index", "minute")
|
|
c.add("meter_energy_watt_hours_total", "Total energy consumed in watt-hours, converted from the Shelly watt-minute total.", "index")
|
|
|
|
c.add("emeter_power_watts", "Current active power measured by an energy meter in watts.", "index")
|
|
c.add("emeter_reactive_power_var", "Current reactive power measured by an energy meter in var.", "index")
|
|
c.add("emeter_power_factor", "Power factor measured by an energy meter.", "index")
|
|
c.add("emeter_current_amperes", "Current measured by an energy meter in amperes.", "index")
|
|
c.add("emeter_voltage_volts", "RMS voltage measured by an energy meter in volts.", "index")
|
|
c.add("emeter_valid", "Whether the energy meter reading is valid (1) or not (0).", "index")
|
|
c.add("emeter_energy_watt_hours_total", "Total energy consumed as reported by the energy meter in watt-hours.", "index")
|
|
c.add("emeter_returned_energy_watt_hours_total", "Total energy returned to the grid in watt-hours.", "index")
|
|
c.add("total_power_watts", "Total active power across all device channels in watts.")
|
|
|
|
c.add("roller_info", "Roller operating state.", "index", "state", "stop_reason", "last_direction")
|
|
c.add("roller_power_watts", "Current roller power consumption in watts.", "index")
|
|
c.add("roller_valid", "Whether the roller power reading is valid (1) or not (0).", "index")
|
|
c.add("roller_safety_switch", "Whether the roller safety switch is active (1) or not (0).", "index")
|
|
c.add("roller_overtemperature", "Whether roller overtemperature protection is active (1) or not (0).", "index")
|
|
c.add("roller_position_percent", "Current roller position in percent.", "index")
|
|
c.add("roller_calibrating", "Whether roller calibration is running (1) or not (0).", "index")
|
|
c.add("roller_positioning", "Whether roller positioning control is available (1) or not (0).", "index")
|
|
|
|
c.add("light_info", "Light operating mode.", "index", "mode")
|
|
c.add("light_on", "Whether the light output is on (1) or off (0).", "index")
|
|
c.add("light_has_timer", "Whether a light timer is active (1) or not (0).", "index")
|
|
c.add("light_timer_remaining_seconds", "Remaining duration of the active light timer in seconds.", "index")
|
|
c.add("light_brightness_percent", "Light brightness in percent.", "index")
|
|
c.add("light_red", "Red channel value from 0 to 255.", "index")
|
|
c.add("light_green", "Green channel value from 0 to 255.", "index")
|
|
c.add("light_blue", "Blue channel value from 0 to 255.", "index")
|
|
c.add("light_white", "White channel value from 0 to 255.", "index")
|
|
c.add("light_gain_percent", "Color mode gain in percent.", "index")
|
|
c.add("light_color_temperature_kelvin", "Configured white color temperature in kelvin.", "index")
|
|
c.add("light_effect", "Selected light effect number.", "index")
|
|
|
|
c.add("temperature_celsius", "Device or sensor temperature in degrees Celsius.")
|
|
c.add("temperature_valid", "Whether the temperature reading is valid (1) or not (0).")
|
|
c.add("temperature_status_info", "Device temperature status.", "status")
|
|
c.add("overtemperature", "Whether overtemperature protection is active (1) or not (0).")
|
|
c.add("humidity_percent", "Relative humidity in percent.")
|
|
c.add("humidity_valid", "Whether the humidity reading is valid (1) or not (0).")
|
|
c.add("battery_percent", "Estimated remaining battery capacity in percent.")
|
|
c.add("battery_voltage_volts", "Measured battery voltage in volts.")
|
|
c.add("illuminance_lux", "Measured illuminance in lux.")
|
|
c.add("illuminance_valid", "Whether the illuminance reading is valid (1) or not (0).")
|
|
c.add("illuminance_info", "Classified illumination level.", "illumination")
|
|
c.add("sensor_valid", "Whether the primary sensor is valid (1) or not (0).")
|
|
c.add("sensor_error", "Product-specific sensor error code.")
|
|
c.add("connect_retries", "Number of Wi-Fi connection retries during the current wake cycle.")
|
|
c.add("motion", "Whether motion is detected (1) or not (0).")
|
|
c.add("motion_active", "Whether motion detection is active (1) or not (0).")
|
|
c.add("motion_timestamp_seconds", "Unix timestamp of the motion sensor reading.")
|
|
c.add("vibration", "Whether vibration is detected (1) or not (0).")
|
|
c.add("charger_connected", "Whether an external charger is connected (1) or not (0).")
|
|
c.add("smoke", "Whether smoke is detected (1) or not (0).")
|
|
c.add("flood", "Whether a flood condition is detected (1) or not (0).")
|
|
c.add("rain_sensor_mode", "Whether rain sensor mode is enabled (1) or not (0).")
|
|
c.add("door_window_info", "Door/window sensor state.", "state")
|
|
c.add("tilt_degrees", "Door/window sensor tilt in degrees.")
|
|
c.add("vibration_value", "Raw door/window vibration state; -1 means disabled.")
|
|
c.add("vibration_time_seconds", "Door/window vibration state validity time in seconds.")
|
|
c.add("adc_voltage_volts", "Voltage measured by an ADC input in volts.", "index")
|
|
c.add("external_temperature_celsius", "Temperature measured by an external sensor in degrees Celsius.", "index", "hardware_id")
|
|
c.add("external_humidity_percent", "Relative humidity measured by an external sensor in percent.", "index", "hardware_id")
|
|
c.add("thermostat_valve_position_percent", "Thermostatic valve position in percent.", "index")
|
|
c.add("thermostat_target_enabled", "Whether automatic target temperature control is enabled (1) or not (0).", "index")
|
|
c.add("thermostat_target_temperature_celsius", "Thermostat target temperature in degrees Celsius.", "index")
|
|
c.add("thermostat_temperature_celsius", "Temperature measured by the thermostat in degrees Celsius.", "index")
|
|
c.add("thermostat_temperature_valid", "Whether the thermostat temperature reading is valid (1) or not (0).", "index")
|
|
c.add("thermostat_schedule_enabled", "Whether the thermostat schedule is enabled (1) or not (0).", "index")
|
|
c.add("thermostat_schedule_profile", "Selected thermostat schedule profile.", "index")
|
|
c.add("thermostat_boost_minutes", "Remaining or configured thermostat boost duration in minutes.", "index")
|
|
c.add("thermostat_window_open", "Whether the thermostat reports an open window (1) or not (0).", "index")
|
|
c.add("thermostat_calibrated", "Whether the thermostatic valve is calibrated (1) or not (0).")
|
|
|
|
c.add("gas_concentration_ppm", "Measured combustible gas concentration in parts per million.")
|
|
c.add("gas_concentration_valid", "Whether the gas concentration reading is valid (1) or not (0).")
|
|
c.add("gas_sensor_info", "Gas sensor operating and alarm state.", "sensor_state", "self_test_state", "alarm_state")
|
|
c.add("gas_valve_info", "Gas valve addon state.", "index", "state")
|
|
}
|
|
|
|
func (c *gen1Collector) add(name, help string, extraLabels ...string) {
|
|
labels := append([]string{"device"}, extraLabels...)
|
|
c.descriptors[name] = prometheus.NewDesc("shelly_"+name, help, labels, nil)
|
|
}
|
|
|
|
func (c *gen1Collector) Describe(channel chan<- *prometheus.Desc) {
|
|
c.base.describe(channel)
|
|
for _, descriptor := range c.descriptors {
|
|
channel <- descriptor
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) Collect(channel chan<- prometheus.Metric) {
|
|
started := time.Now()
|
|
var status gen1Status
|
|
err := c.client.GetStatus(context.Background(), &status)
|
|
c.base.collect(channel, err == nil, time.Since(started).Seconds())
|
|
if err != nil {
|
|
log.Warnf("Cannot collect status from Shelly device %q: %v", c.base.device, err)
|
|
return
|
|
}
|
|
|
|
c.collectCommon(channel, &status)
|
|
c.collectRelays(channel, status.Relays)
|
|
inputs := status.Inputs
|
|
if len(inputs) == 0 && status.Input != nil {
|
|
inputs = []gen1Input{{Input: status.Input}}
|
|
}
|
|
c.collectInputs(channel, inputs)
|
|
c.collectMeters(channel, status.Meters)
|
|
c.collectEMeters(channel, status.EMeters)
|
|
c.collectRollers(channel, status.Rollers)
|
|
c.collectLights(channel, status.Lights)
|
|
c.collectThermostats(channel, &status)
|
|
c.collectSensors(channel, &status)
|
|
}
|
|
|
|
func (c *gen1Collector) collectCommon(channel chan<- prometheus.Metric, status *gen1Status) {
|
|
firmware := ""
|
|
if status.Update != nil {
|
|
firmware = status.Update.OldVersion
|
|
}
|
|
c.gauge(channel, "device_info", 1, c.base.product, status.MAC, firmware)
|
|
|
|
if status.WiFiStation != nil {
|
|
c.gauge(channel, "wifi_info", 1, status.WiFiStation.SSID, status.WiFiStation.IP)
|
|
c.gauge(channel, "wifi_connected", boolFloat(status.WiFiStation.Connected))
|
|
c.gauge(channel, "wifi_rssi_dbm", float64(status.WiFiStation.RSSI))
|
|
}
|
|
if status.Cloud != nil {
|
|
c.gauge(channel, "cloud_enabled", boolFloat(status.Cloud.Enabled))
|
|
c.gauge(channel, "cloud_connected", boolFloat(status.Cloud.Connected))
|
|
}
|
|
if status.MQTT != nil {
|
|
c.gauge(channel, "mqtt_connected", boolFloat(status.MQTT.Connected))
|
|
}
|
|
if status.HasUpdate != nil || status.Update != nil {
|
|
available := status.HasUpdate != nil && *status.HasUpdate
|
|
if status.Update != nil {
|
|
available = available || status.Update.HasUpdate
|
|
}
|
|
c.gauge(channel, "update_available", boolFloat(available))
|
|
}
|
|
if status.Update != nil {
|
|
c.gauge(channel, "update_info", 1, status.Update.Status, status.Update.OldVersion, status.Update.NewVersion)
|
|
}
|
|
if status.Serial != nil {
|
|
c.gauge(channel, "status_serial", float64(*status.Serial))
|
|
}
|
|
if status.RAMTotal != nil {
|
|
c.gauge(channel, "ram_size_bytes", float64(*status.RAMTotal))
|
|
}
|
|
if status.RAMFree != nil {
|
|
c.gauge(channel, "ram_free_bytes", float64(*status.RAMFree))
|
|
}
|
|
if status.FSSize != nil {
|
|
c.gauge(channel, "filesystem_size_bytes", float64(*status.FSSize))
|
|
}
|
|
if status.FSFree != nil {
|
|
c.gauge(channel, "filesystem_free_bytes", float64(*status.FSFree))
|
|
}
|
|
if status.FSMounted != nil {
|
|
c.gauge(channel, "filesystem_mounted", boolFloat(*status.FSMounted))
|
|
}
|
|
if status.Uptime != nil {
|
|
c.gauge(channel, "uptime_seconds", *status.Uptime)
|
|
}
|
|
if status.TotalPower != nil {
|
|
c.gauge(channel, "total_power_watts", *status.TotalPower)
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectRelays(channel chan<- prometheus.Metric, relays []gen1Relay) {
|
|
for index, relay := range relays {
|
|
label := strconv.Itoa(index)
|
|
c.optionalBool(channel, "relay_on", relay.On, label)
|
|
c.optionalBool(channel, "relay_has_timer", relay.HasTimer, label)
|
|
c.optionalGauge(channel, "relay_timer_duration_seconds", relay.TimerDuration, label)
|
|
c.optionalGauge(channel, "relay_timer_remaining_seconds", relay.TimerRemaining, label)
|
|
c.optionalBool(channel, "relay_overpower", relay.Overpower, label)
|
|
c.optionalBool(channel, "relay_valid", relay.Valid, label)
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectInputs(channel chan<- prometheus.Metric, inputs []gen1Input) {
|
|
for index, input := range inputs {
|
|
label := strconv.Itoa(index)
|
|
c.optionalGauge(channel, "input_on", input.Input, label)
|
|
if input.Event != "" || input.LastSequence != "" {
|
|
c.gauge(channel, "input_event_info", 1, label, input.Event, input.LastSequence)
|
|
}
|
|
if input.EventCount != nil && *input.EventCount >= 0 {
|
|
c.counter(channel, "input_event_count_total", *input.EventCount, label)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectMeters(channel chan<- prometheus.Metric, meters []gen1Meter) {
|
|
for index, meter := range meters {
|
|
label := strconv.Itoa(index)
|
|
c.optionalGauge(channel, "meter_power_watts", meter.Power, label)
|
|
c.optionalBool(channel, "meter_valid", meter.Valid, label)
|
|
c.optionalGauge(channel, "meter_timestamp_seconds", meter.Timestamp, label)
|
|
if meter.Overpower != nil {
|
|
c.optionalGauge(channel, "meter_overpower_threshold_watts", meter.Overpower.Number, label)
|
|
c.optionalBool(channel, "meter_overpower", meter.Overpower.Bool, label)
|
|
}
|
|
if meter.Total != nil && *meter.Total >= 0 {
|
|
c.counter(channel, "meter_energy_watt_hours_total", *meter.Total/60, label)
|
|
}
|
|
for minute, recentEnergy := range meter.Counters {
|
|
c.gauge(channel, "meter_recent_energy_watt_minutes", recentEnergy, label, strconv.Itoa(minute))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectEMeters(channel chan<- prometheus.Metric, meters []gen1EMeter) {
|
|
for index, meter := range meters {
|
|
label := strconv.Itoa(index)
|
|
c.optionalGauge(channel, "emeter_power_watts", meter.Power, label)
|
|
c.optionalGauge(channel, "emeter_reactive_power_var", meter.ReactivePower, label)
|
|
c.optionalGauge(channel, "emeter_power_factor", meter.PowerFactor, label)
|
|
c.optionalGauge(channel, "emeter_current_amperes", meter.Current, label)
|
|
c.optionalGauge(channel, "emeter_voltage_volts", meter.Voltage, label)
|
|
c.optionalBool(channel, "emeter_valid", meter.Valid, label)
|
|
if meter.Total != nil && *meter.Total >= 0 {
|
|
c.counter(channel, "emeter_energy_watt_hours_total", *meter.Total, label)
|
|
}
|
|
if meter.TotalReturned != nil && *meter.TotalReturned >= 0 {
|
|
c.counter(channel, "emeter_returned_energy_watt_hours_total", *meter.TotalReturned, label)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectRollers(channel chan<- prometheus.Metric, rollers []gen1Roller) {
|
|
for index, roller := range rollers {
|
|
label := strconv.Itoa(index)
|
|
if roller.State != "" || roller.StopReason != "" || roller.LastDirection != "" {
|
|
c.gauge(channel, "roller_info", 1, label, roller.State, roller.StopReason, roller.LastDirection)
|
|
}
|
|
c.optionalGauge(channel, "roller_power_watts", roller.Power, label)
|
|
c.optionalBool(channel, "roller_valid", roller.Valid, label)
|
|
c.optionalBool(channel, "roller_safety_switch", roller.SafetySwitch, label)
|
|
c.optionalBool(channel, "roller_overtemperature", roller.Overtemperature, label)
|
|
c.optionalGauge(channel, "roller_position_percent", roller.CurrentPosition, label)
|
|
c.optionalBool(channel, "roller_calibrating", roller.Calibrating, label)
|
|
c.optionalBool(channel, "roller_positioning", roller.Positioning, label)
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectLights(channel chan<- prometheus.Metric, lights []gen1Light) {
|
|
for index, light := range lights {
|
|
label := strconv.Itoa(index)
|
|
if light.Mode != "" {
|
|
c.gauge(channel, "light_info", 1, label, light.Mode)
|
|
}
|
|
c.optionalBool(channel, "light_on", light.On, label)
|
|
c.optionalBool(channel, "light_has_timer", light.HasTimer, label)
|
|
c.optionalGauge(channel, "light_timer_remaining_seconds", light.TimerRemaining, label)
|
|
c.optionalGauge(channel, "light_brightness_percent", light.Brightness, label)
|
|
c.optionalGauge(channel, "light_red", light.Red, label)
|
|
c.optionalGauge(channel, "light_green", light.Green, label)
|
|
c.optionalGauge(channel, "light_blue", light.Blue, label)
|
|
c.optionalGauge(channel, "light_white", light.White, label)
|
|
c.optionalGauge(channel, "light_gain_percent", light.Gain, label)
|
|
c.optionalGauge(channel, "light_color_temperature_kelvin", light.Temperature, label)
|
|
c.optionalGauge(channel, "light_effect", light.Effect, label)
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectThermostats(channel chan<- prometheus.Metric, status *gen1Status) {
|
|
if len(status.Thermostats) > 0 {
|
|
c.optionalBool(channel, "thermostat_calibrated", status.Calibrated)
|
|
}
|
|
for index, thermostat := range status.Thermostats {
|
|
label := strconv.Itoa(index)
|
|
c.optionalGauge(channel, "thermostat_valve_position_percent", thermostat.Position, label)
|
|
if thermostat.Target != nil {
|
|
c.optionalBool(channel, "thermostat_target_enabled", thermostat.Target.Enabled, label)
|
|
if thermostat.Target.Units == "C" {
|
|
c.optionalGauge(channel, "thermostat_target_temperature_celsius", thermostat.Target.Value, label)
|
|
}
|
|
}
|
|
if thermostat.Temperature != nil {
|
|
temperature := thermostat.Temperature.C
|
|
if temperature == nil && thermostat.Temperature.Units == "C" {
|
|
temperature = thermostat.Temperature.Value
|
|
}
|
|
c.optionalGauge(channel, "thermostat_temperature_celsius", temperature, label)
|
|
c.optionalBool(channel, "thermostat_temperature_valid", thermostat.Temperature.Valid, label)
|
|
}
|
|
c.optionalBool(channel, "thermostat_schedule_enabled", thermostat.Schedule, label)
|
|
c.optionalGauge(channel, "thermostat_schedule_profile", thermostat.ScheduleProfile, label)
|
|
c.optionalGauge(channel, "thermostat_boost_minutes", thermostat.BoostMinutes, label)
|
|
c.optionalBool(channel, "thermostat_window_open", thermostat.WindowOpen, label)
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) collectSensors(channel chan<- prometheus.Metric, status *gen1Status) {
|
|
temperature := status.Temperature
|
|
if temperature == nil && status.TemperatureSensor != nil {
|
|
temperature = status.TemperatureSensor.C
|
|
if temperature == nil && status.TemperatureSensor.Units == "C" {
|
|
temperature = status.TemperatureSensor.Value
|
|
}
|
|
}
|
|
c.optionalGauge(channel, "temperature_celsius", temperature)
|
|
if status.TemperatureSensor != nil {
|
|
c.optionalBool(channel, "temperature_valid", status.TemperatureSensor.Valid)
|
|
}
|
|
if status.TemperatureStatus != "" {
|
|
c.gauge(channel, "temperature_status_info", 1, status.TemperatureStatus)
|
|
}
|
|
c.optionalBool(channel, "overtemperature", status.Overtemperature)
|
|
if status.Humidity != nil {
|
|
c.optionalGauge(channel, "humidity_percent", status.Humidity.Value)
|
|
c.optionalBool(channel, "humidity_valid", status.Humidity.Valid)
|
|
}
|
|
if status.Battery != nil {
|
|
c.optionalGauge(channel, "battery_percent", status.Battery.Value)
|
|
c.optionalGauge(channel, "battery_voltage_volts", status.Battery.Voltage)
|
|
}
|
|
if status.Lux != nil {
|
|
c.optionalGauge(channel, "illuminance_lux", status.Lux.Value)
|
|
c.optionalBool(channel, "illuminance_valid", status.Lux.Valid)
|
|
if status.Lux.Illumination != "" {
|
|
c.gauge(channel, "illuminance_info", 1, status.Lux.Illumination)
|
|
}
|
|
}
|
|
c.optionalGauge(channel, "sensor_error", status.SensorError)
|
|
c.optionalGauge(channel, "connect_retries", status.ConnectRetries)
|
|
c.optionalBool(channel, "charger_connected", status.Charger)
|
|
c.optionalBool(channel, "smoke", status.Smoke)
|
|
c.optionalBool(channel, "flood", status.Flood)
|
|
c.optionalBool(channel, "rain_sensor_mode", status.RainSensor)
|
|
|
|
motion := status.Motion
|
|
sensorValid := status.Valid
|
|
if status.Sensor != nil {
|
|
if status.Sensor.Motion != nil {
|
|
motion = status.Sensor.Motion
|
|
}
|
|
if status.Sensor.Valid != nil {
|
|
sensorValid = status.Sensor.Valid
|
|
}
|
|
c.optionalBool(channel, "motion_active", status.Sensor.Active)
|
|
c.optionalGauge(channel, "motion_timestamp_seconds", status.Sensor.Timestamp)
|
|
c.optionalBool(channel, "vibration", status.Sensor.Vibration)
|
|
if status.Sensor.State != "" {
|
|
c.gauge(channel, "door_window_info", 1, status.Sensor.State)
|
|
}
|
|
}
|
|
c.optionalBool(channel, "motion", motion)
|
|
c.optionalBool(channel, "sensor_valid", sensorValid)
|
|
if status.Acceleration != nil {
|
|
c.optionalGauge(channel, "tilt_degrees", status.Acceleration.Tilt)
|
|
c.optionalGauge(channel, "vibration_value", status.Acceleration.Vibration)
|
|
c.optionalGauge(channel, "vibration_time_seconds", status.Acceleration.VibrationTime)
|
|
}
|
|
|
|
for index, adc := range status.ADCs {
|
|
c.optionalGauge(channel, "adc_voltage_volts", adc.Voltage, strconv.Itoa(index))
|
|
}
|
|
for _, index := range sortedKeys(status.ExternalTemperature) {
|
|
sensor := status.ExternalTemperature[index]
|
|
c.optionalGauge(channel, "external_temperature_celsius", sensor.C, index, sensor.HardwareID)
|
|
}
|
|
for _, index := range sortedKeys(status.ExternalHumidity) {
|
|
sensor := status.ExternalHumidity[index]
|
|
c.optionalGauge(channel, "external_humidity_percent", sensor.Humidity, index, sensor.HardwareID)
|
|
}
|
|
|
|
if status.GasSensor != nil {
|
|
c.gauge(channel, "gas_sensor_info", 1, status.GasSensor.SensorState, status.GasSensor.SelfTestState, status.GasSensor.AlarmState)
|
|
}
|
|
if status.Concentration != nil {
|
|
c.optionalGauge(channel, "gas_concentration_ppm", status.Concentration.PPM)
|
|
c.optionalBool(channel, "gas_concentration_valid", status.Concentration.Valid)
|
|
}
|
|
for index, valve := range status.Valves {
|
|
c.gauge(channel, "gas_valve_info", 1, strconv.Itoa(index), valve.State)
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) gauge(channel chan<- prometheus.Metric, name string, value float64, labels ...string) {
|
|
c.emit(channel, name, prometheus.GaugeValue, value, labels...)
|
|
}
|
|
|
|
func (c *gen1Collector) counter(channel chan<- prometheus.Metric, name string, value float64, labels ...string) {
|
|
c.emit(channel, name, prometheus.CounterValue, value, labels...)
|
|
}
|
|
|
|
func (c *gen1Collector) emit(channel chan<- prometheus.Metric, name string, valueType prometheus.ValueType, value float64, labels ...string) {
|
|
allLabels := append([]string{c.base.device}, labels...)
|
|
channel <- prometheus.MustNewConstMetric(c.descriptors[name], valueType, value, allLabels...)
|
|
}
|
|
|
|
func (c *gen1Collector) optionalGauge(channel chan<- prometheus.Metric, name string, value *float64, labels ...string) {
|
|
if value != nil {
|
|
c.gauge(channel, name, *value, labels...)
|
|
}
|
|
}
|
|
|
|
func (c *gen1Collector) optionalBool(channel chan<- prometheus.Metric, name string, value *bool, labels ...string) {
|
|
if value != nil {
|
|
c.gauge(channel, name, boolFloat(*value), labels...)
|
|
}
|
|
}
|
|
|
|
func boolFloat(value bool) float64 {
|
|
if value {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func sortedKeys[T any](values map[string]T) []string {
|
|
keys := make([]string, 0, len(values))
|
|
for key := range values {
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
return keys
|
|
}
|