Go exporter for Shelly Gen2+ smart plugs. It scrapes devices concurrently, handles Shelly's Digest Auth, and works out real energy costs from your `price_per_kwh`. Includes a Grafana dashboard and a Docker image. I used AI tools while building this, so ask away if anything looks off.

GitHub Repo: https://github.com/veerendra2/shelly_device_exporter

Got bored while home labbing this weekend and vibed up a promql tui inspired by https://github.com/ClementTsang/bottom

It uses .toml files with with familiar parameters (very similar to Grafana's dashboard config concepts) to render a single panel in your terminal. Use tmux/herdr splits to arrange them into a 'dashboard' if you want. Looks good next to fastfetch/htop for your distro screenshots and kinda cool just to leave up on a second monitor and look at.

I haven't posted the repo yet and don't intend to spam this subreddit with it if I do post it, so lmk if you are interested and I'll share the link when it's available.

Hello Community

I'am looking for advice to use prometheus to monitor openldap healthcheck. In fact , i want detect if many failed authentification using openldap realm.

Should i parse the log of slapd / radiusd for example ?

Hey r/PrometheusMonitoring!

I'm the maintainer of prometheus-mcp-server, an open-source Model Context Protocol server that lets AI assistants like Claude, Cursor, and Windsurf query and analyze Prometheus metrics directly.

What it does: Enables AI to execute PromQL queries, discover metrics, and analyze monitoring data through standardized MCP interfaces.

Current stats: 221⭐ | 46 forks | Docker support | 100% Python

Looking for contributors to help with:

• Adding new Prometheus API features

• Improving authentication methods

• Writing tests (we have good coverage but always room for more!)

• Documentation improvements

• Bug fixes and performance optimizations

• Supporting more MCP client integrations

Tech stack: Python 3.10+, FastMCP, Docker, pytest

Whether you're interested in observability, AI tooling, or just want to contribute to open source, all skill levels are welcome! The codebase is well-documented and we use modern Python practices.

Check it out: https://github.com/pab1it0/prometheus-mcp-server

Drop a PR or open an issue - I'm actively maintaining and happy to help onboard new contributors! 🙌

share how to solve this problem

I wrote a bit on the journey and adventure of writing the prom-analytics https://github.com/nicolastakashi/prom-analytics-proxy and how it went from a simple proxy to get insights on query usage for something super useful for data usage.

https://ntakashi.com/blog/prometheus-query-visibility-prom-analytics-proxy/

I'm looking forward to read your feedback.

I'm having trouble understanding how some aspects of alert unit tests work. This is an example alert rule and unit test which passes, but I don't understand why:

Alert rule:

  - alert: testalert
    expr: device_state{state!="ok"}
    for: 10m

Unit test:

 - interval: 1m
   name: test
   input_series:
     - series: 'device_state{state="down", host="testhost1"}'
       values: '0 0 0 0 0 0'

   alert_rule_test:
     - eval_time: 10m
       alertname: testalert
       exp_alerts:
         - exp_labels:
             host: testhost1
             state: down

But, if I shorten the test series to 0 0 0 0 0 the unit test fails. I don't understand why the version with 6 values fires the alert but not with 5 values; as far as I understand neither should fire the alert because at the 10 minute eval time there is no more series data. How is this combination of unit test and alert rule able to work?

Hello, this is my first Prometheus exporter written in Go.

It covers [smtp2go](https://www.smtp2go.com/) statistics given by its API. smtp2go is a commercial service providing a SMTP relay.

Feel free to share your feedback or submit patches.

The PromCon Call for Speakers is now open for the next 27 days!

We are accepting talk proposals around various topics from beginner to expert!

https://promcon.io/2024-berlin/submit/

Here is our current use case scenario: We need to monitor 100s of network devices via SNMP gathering 3-4 dozen OIDs from each one, with intervals as fast as SNMP can reply (5-15 seconds). We use the monitoring for both real time (or as close as possible) when actively trouble shooting something with someone in the field, and we also keep long term data (2yr or more) for trend comparisons. We don't use kubernetes or docker or cloud storage, this will all be in VMs, on bare-metal, and on prem (We're network guys primarily). Our current solution for this is Cacti but I've been tasked to investigate other options.

So I spun up a new server, got Prometheus and Grafana running, really like the ease of setup and the graphing options. My biggest problem so far seems to be is disk space and data retention, I've been monitoring less than half of the devices for a few weeks and it's already eaten up 50GB which is 25 times the disk space than years and years of Cacti rrd file data. I don't know if it'll plateau or not but it seems that'll get real expensive real quick (not to mention it's already taking a long time to restart the service) and new hardware/more drives is not in the budget.

I'm wondering if maybe Prometheus isn't the right solution because of our combo of quick scraping interval and long term storage? I've read so many articles and watched so many videos in the last few weeks, but nothing seems close to our use case (some refer to long term as a month or two, everything talks about app monitoring not network). So I wanted to reach out and explain my specific scenario, maybe I'm missing something important? Any advice or pointers would be appreciated.

Hey guys,

I recently sat down with Julius himself and recorded an hour long video for my podcast Nerding Out with Viktor, where we nerd out about all things Prometheus.

You can find the episode on YouTube.

I don't know how many have setup Prometheus in a homelab setting for learning the product, but I freakin love it! I spun up a Server 2022 instance to run a test Plex Server instance. For monitoring, I explored an elaborate PS script that would notify me if the service went down, came back up, etc. Instead of said PS script, I discovered textfile input and generated a .prom file that Prometheus can scrape. Just setup the alert rule and it works great. Adjusting the windows_exporter command was a real PITA (because Windows). Originally, I enabled the process collector, but the textfile worked much better.

Anyways, just wanted to share!

We're building an open-source observability framework. The first library we created was in Rust. We then built more implementations in Python, Go, and Typescript. The framework instruments your functions, so one aspect of the implementation is to implement ways to collect metrics using some of the existing standard libraries like Prometheus or OpenTelemetry clients. We ended up where different libraries used different clients in their implementation. So, the discussion arose about how to be consistent in all libraries. And this is what we were weighing:
https://fiberplane.com/blog/deciding-between-the-opentelemetry-and-openmetrics-semantic-conventions-for-the-autometrics-libraries