prometheus_handler.h

Go to the documentation of this file.

#pragma once
#include "esphome/core/defines.h"
#if defined(USE_NETWORK) && !defined(USE_ZEPHYR)
#include <map>
#include <utility>
 
#include "esphome/components/web_server_base/web_server_base.h"
#include "esphome/core/component.h"
#include "esphome/core/controller.h"
#include "esphome/core/entity_base.h"
#ifdef USE_CLIMATE
#include "esphome/core/log.h"
#endif
 
namespace esphome::prometheus {
 
class PrometheusHandler : public AsyncWebHandler, public Component {
 public:
  PrometheusHandler(web_server_base::WebServerBase *base) : base_(base) {}
 
  void set_include_internal(bool include_internal) { include_internal_ = include_internal; }
 
  void add_label_id(EntityBase *obj, const std::string &value) { relabel_map_id_.insert({obj, value}); }
 
  void add_label_name(EntityBase *obj, const std::string &value) { relabel_map_name_.insert({obj, value}); }
 
  bool canHandle(AsyncWebServerRequest *request) const override {
    if (request->method() != HTTP_GET)
      return false;
#ifdef USE_ESP32
    char url_buf[AsyncWebServerRequest::URL_BUF_SIZE];
    return request->url_to(url_buf) == "/metrics";
#else
    return request->url() == ESPHOME_F("/metrics");
#endif
  }
 
  void handleRequest(AsyncWebServerRequest *req) override;
 
  void setup() override {
    this->base_->init();
    this->base_->add_handler(this);
  }
  float get_setup_priority() const override {
    // After WiFi
    return setup_priority::WIFI - 1.0f;
  }
 
 protected:
  std::string relabel_id_(EntityBase *obj);
  std::string relabel_name_(EntityBase *obj);
  void add_area_label_(AsyncResponseStream *stream, std::string &area);
  void add_node_label_(AsyncResponseStream *stream, std::string &node);
  void add_friendly_name_label_(AsyncResponseStream *stream, std::string &friendly_name);
#ifdef USE_ESP8266
  void print_metric_labels_(AsyncResponseStream *stream, const __FlashStringHelper *metric_name, EntityBase *obj,
                            std::string &area, std::string &node, std::string &friendly_name);
#else
  void print_metric_labels_(AsyncResponseStream *stream, const char *metric_name, EntityBase *obj, std::string &area,
                            std::string &node, std::string &friendly_name);
#endif
 
#ifdef USE_SENSOR
  void sensor_type_(AsyncResponseStream *stream);
  void sensor_row_(AsyncResponseStream *stream, sensor::Sensor *obj, std::string &area, std::string &node,
                   std::string &friendly_name);
#endif
 
#ifdef USE_BINARY_SENSOR
  void binary_sensor_type_(AsyncResponseStream *stream);
  void binary_sensor_row_(AsyncResponseStream *stream, binary_sensor::BinarySensor *obj, std::string &area,
                          std::string &node, std::string &friendly_name);
#endif
 
#ifdef USE_FAN
  void fan_type_(AsyncResponseStream *stream);
  void fan_row_(AsyncResponseStream *stream, fan::Fan *obj, std::string &area, std::string &node,
                std::string &friendly_name);
#endif
 
#ifdef USE_LIGHT
  void light_type_(AsyncResponseStream *stream);
  void light_row_(AsyncResponseStream *stream, light::LightState *obj, std::string &area, std::string &node,
                  std::string &friendly_name);
#endif
 
#ifdef USE_COVER
  void cover_type_(AsyncResponseStream *stream);
  void cover_row_(AsyncResponseStream *stream, cover::Cover *obj, std::string &area, std::string &node,
                  std::string &friendly_name);
#endif
 
#ifdef USE_SWITCH
  void switch_type_(AsyncResponseStream *stream);
  void switch_row_(AsyncResponseStream *stream, switch_::Switch *obj, std::string &area, std::string &node,
                   std::string &friendly_name);
#endif
 
#ifdef USE_LOCK
  void lock_type_(AsyncResponseStream *stream);
  void lock_row_(AsyncResponseStream *stream, lock::Lock *obj, std::string &area, std::string &node,
                 std::string &friendly_name);
#endif
 
#ifdef USE_EVENT
  void event_type_(AsyncResponseStream *stream);
  void event_row_(AsyncResponseStream *stream, event::Event *obj, std::string &area, std::string &node,
                  std::string &friendly_name);
#endif
 
#ifdef USE_TEXT
  void text_type_(AsyncResponseStream *stream);
  void text_row_(AsyncResponseStream *stream, text::Text *obj, std::string &area, std::string &node,
                 std::string &friendly_name);
#endif
 
#ifdef USE_TEXT_SENSOR
  void text_sensor_type_(AsyncResponseStream *stream);
  void text_sensor_row_(AsyncResponseStream *stream, text_sensor::TextSensor *obj, std::string &area, std::string &node,
                        std::string &friendly_name);
#endif
 
#ifdef USE_NUMBER
  void number_type_(AsyncResponseStream *stream);
  void number_row_(AsyncResponseStream *stream, number::Number *obj, std::string &area, std::string &node,
                   std::string &friendly_name);
#endif
 
#ifdef USE_SELECT
  void select_type_(AsyncResponseStream *stream);
  void select_row_(AsyncResponseStream *stream, select::Select *obj, std::string &area, std::string &node,
                   std::string &friendly_name);
#endif
 
#ifdef USE_MEDIA_PLAYER
  void media_player_type_(AsyncResponseStream *stream);
  void media_player_row_(AsyncResponseStream *stream, media_player::MediaPlayer *obj, std::string &area,
                         std::string &node, std::string &friendly_name);
#endif
 
#ifdef USE_UPDATE
  void update_entity_type_(AsyncResponseStream *stream);
  void update_entity_row_(AsyncResponseStream *stream, update::UpdateEntity *obj, std::string &area, std::string &node,
                          std::string &friendly_name);
  void handle_update_state_(AsyncResponseStream *stream, update::UpdateState state);
#endif
 
#ifdef USE_VALVE
  void valve_type_(AsyncResponseStream *stream);
  void valve_row_(AsyncResponseStream *stream, valve::Valve *obj, std::string &area, std::string &node,
                  std::string &friendly_name);
#endif
 
#ifdef USE_CLIMATE
  void climate_type_(AsyncResponseStream *stream);
  void climate_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
                    std::string &friendly_name);
  void climate_failed_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
                           std::string &friendly_name, std::string &category, bool is_failed_value);
  void climate_setting_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
                            std::string &friendly_name, std::string &setting, const LogString *setting_value);
  void climate_value_row_(AsyncResponseStream *stream, climate::Climate *obj, std::string &area, std::string &node,
                          std::string &friendly_name, std::string &category, const char *climate_value);
#endif
 
  web_server_base::WebServerBase *base_;
  bool include_internal_{false};
  std::map<EntityBase *, std::string> relabel_map_id_;
  std::map<EntityBase *, std::string> relabel_map_name_;
};
 
}  // namespace esphome::prometheus
 
#endif  // USE_NETWORK && !USE_ZEPHYR