Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/autometrics-dev/autometrics-rs
Easily add metrics to your code that actually help you spot and debug issues in production. Built on Prometheus and OpenTelemetry.
https://github.com/autometrics-dev/autometrics-rs
metrics monitoring observability opentelemetry prometheus rust telemetry tracing
Last synced: about 19 hours ago
JSON representation
Easily add metrics to your code that actually help you spot and debug issues in production. Built on Prometheus and OpenTelemetry.
- Host: GitHub
- URL: https://github.com/autometrics-dev/autometrics-rs
- Owner: autometrics-dev
- License: apache-2.0
- Created: 2023-01-12T10:58:47.000Z (almost 2 years ago)
- Default Branch: main
- Last Pushed: 2024-10-21T22:52:29.000Z (about 2 months ago)
- Last Synced: 2024-10-29T15:24:59.411Z (about 1 month ago)
- Topics: metrics, monitoring, observability, opentelemetry, prometheus, rust, telemetry, tracing
- Language: Rust
- Homepage: https://autometrics.dev
- Size: 827 KB
- Stars: 801
- Watchers: 10
- Forks: 28
- Open Issues: 12
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE-APACHE
Awesome Lists containing this project
- awesome-cloudops - Autometrics - dev/autometrics-rs" alt="Stars"><br><img align="right" src="https://img.shields.io/github/issues-raw/autometrics-dev/autometrics-rs" alt="Issues"><br><img align="right" src="https://img.shields.io/github/last-commit/autometrics-dev/autometrics-rs">](https://github.com/autometrics-dev/autometrics-rs) | | Monitoring tool for code | Easily add metrics to your code that actually help you spot and debug issues in production. Built on Prometheus and OpenTelemetry | (Tools)
README
## NOTE: Autometrics is no longer actively maintained.
[](https://docs.rs/autometrics)
[](https://crates.io/crates/autometrics)
[](https://discord.gg/kHtwcH8As9)
Metrics are a powerful and cost-efficient tool for understanding the health and performance of your code in production. But it's hard to decide what metrics to track and even harder to write queries to understand the data.
Autometrics provides a macro that makes it trivial to instrument any function with the most useful metrics: request rate, error rate, and latency. It standardizes these metrics and then generates powerful Prometheus queries based on your function details to help you quickly identify and debug issues in production.
## Benefits
- [✨ `#[autometrics]`](https://docs.rs/autometrics/latest/autometrics/attr.autometrics.html) macro adds useful metrics to any function or `impl` block, without you thinking about what metrics to collect
- 💡 Generates powerful Prometheus queries to help quickly identify and debug issues in production
- 🔗 Injects links to live Prometheus charts directly into each function's doc comments
- [📊 Grafana dashboards](https://github.com/autometrics-dev/autometrics-shared#dashboards) work without configuration to visualize the performance of functions & [SLOs](https://docs.rs/autometrics/latest/autometrics/objectives/index.html)
- 🔍 Correlates your code's version with metrics to help identify commits that introduced errors or latency
- 📏 Standardizes metrics across services and teams to improve debugging
- ⚖️ Function-level metrics provide useful granularity without exploding cardinality
- [⚡ Minimal runtime overhead](#benchmarks)
## Advanced Features
- [🚨 Define alerts](https://docs.rs/autometrics/latest/autometrics/objectives/index.html) using SLO best practices directly in your source code
- [📍 Attach exemplars](https://docs.rs/autometrics/latest/autometrics/exemplars/index.html) automatically to connect metrics with traces
- [⚙️ Configurable](https://docs.rs/autometrics/latest/autometrics/#metrics-backends) metric collection library ([`opentelemetry`](https://crates.io/crates/opentelemetry), [`prometheus`](https://crates.io/crates/prometheus), [`prometheus-client`](https://crates.io/crates/prometheus-client) or [`metrics`](https://crates.io/crates/metrics))
See [autometrics.dev](https://docs.autometrics.dev/) for more details on the ideas behind autometrics.
# Example + Demo
```rust
use autometrics::autometrics;
#[autometrics]
pub async fn create_user() {
// Now this function produces metrics! 📈
}
```
Here is a demo of jumping from function docs to live Prometheus charts:
https://github.com/autometrics-dev/autometrics-rs/assets/3262610/966ed140-1d6c-45f3-a607-64797d5f0233
## Quickstart
1. Add `autometrics` to your project:
```sh
cargo add autometrics --features=prometheus-exporter
```
2. Instrument your functions with the [`#[autometrics]`](https://docs.rs/autometrics/latest/autometrics/attr.autometrics.html) macro
```rust
use autometrics::autometrics;
// Just add the autometrics annotation to your functions
#[autometrics]
pub async fn my_function() {
// Now this function produces metrics!
}
struct MyStruct;
// You can also instrument whole impl blocks
#[autometrics]
impl MyStruct {
pub fn my_method() {
// This method produces metrics too!
}
}
```
Tip: Adding autometrics to all functions using the tracing::instrument macro
You can use a search and replace to add autometrics to all functions instrumented with `tracing::instrument`.
Replace:
```rust
#[instrument]
```
With:
```rust
#[instrument]
#[autometrics]
```
And then let Rust Analyzer tell you which files you need to add `use autometrics::autometrics` at the top of.
Tip: Adding autometrics to all pub functions (not necessarily recommended 😅)
You can use a search and replace to add autometrics to all public functions. Yes, this is a bit nuts.
Use a regular expression search to replace:
```
(pub (?:async)? fn.*)
```
With:
```
#[autometrics]
$1
```
And then let Rust Analyzer tell you which files you need to add `use autometrics::autometrics` at the top of.
3. Export the metrics for Prometheus
For projects not currently using Prometheus metrics
Autometrics includes optional functions to help collect and prepare metrics to be collected by Prometheus.
In your `main` function, initialize the `prometheus_exporter`:
```rust
pub fn main() {
prometheus_exporter::init();
// ...
}
```
And create a route on your API (probably mounted under `/metrics`) that returns the following:
```rust
use autometrics::prometheus_exporter::{self, PrometheusResponse};
/// Export metrics for Prometheus to scrape
pub fn get_metrics() -> PrometheusResponse {
prometheus_exporter::encode_http_response()
}
```
For projects already using custom Prometheus metrics
[Configure `autometrics`](https://docs.rs/autometrics/latest/autometrics/#metrics-libraries) to use the same underlying metrics library you use with the feature flag corresponding to the crate and version you are using.
```toml
[dependencies]
autometrics = {
version = "*",
features = ["prometheus-0_13"],
default-features = false
}
```
The `autometrics` metrics will be produced alongside yours.
> **Note**
>
> You must ensure that you are using the exact same version of the library as `autometrics`. If not, the `autometrics` metrics will not appear in your exported metrics.
> This is because Cargo will include both versions of the crate and the global statics used for the metrics registry will be different.
You do not need to use the Prometheus exporter functions this library provides (you can leave out the `prometheus-exporter` feature flag) and you do not need a separate endpoint for autometrics' metrics.
4. Run Prometheus locally with the [Autometrics CLI](https://docs.autometrics.dev/local-development#getting-started-with-am) or [configure it manually](https://github.com/autometrics-dev#5-configuring-prometheus) to scrape your metrics endpoint
5. (Optional) If you have Grafana, import the [Autometrics dashboards](https://github.com/autometrics-dev/autometrics-shared#dashboards) for an overview and detailed view of the function metrics
## [API Docs](https://docs.rs/autometrics)
## [Examples](./examples)
[](https://gitpod.io/#https://github.com/autometrics-dev/autometrics-rs)
To see autometrics in action:
1. Install [prometheus](https://prometheus.io/download/) locally or download the [Autometrics CLI](https://docs.autometrics.dev/local-development#getting-started-with-am) which will install and configure Prometheus for you locally.
2. Run the [complete example](./examples/full-api):
```shell
cargo run -p example-full-api
```
3. Hover over the [function names](./examples/full-api/src/routes.rs#L13) to see the generated query links
(like in the image above) and view the Prometheus charts
## Benchmarks
Using each of the following metrics libraries, tracking metrics with the `autometrics` macro adds approximately:
- `prometheus-0_13`: 140-150 nanoseconds
- `prometheus-client-0_21`: 150-250 nanoseconds
- `metrics-0_21`: 550-650 nanoseconds
- `opentelemetry-0_20`: 1700-2100 nanoseconds
These were calculated on a 2021 MacBook Pro with the M1 Max chip and 64 GB of RAM.
To run the benchmarks yourself, run the following command, replacing `BACKEND` with the metrics library of your choice:
```sh
cargo bench --features prometheus-exporter,BACKEND
```
## Contributing
Issues, feature suggestions, and pull requests are very welcome!
If you are interested in getting involved:
- Join the conversation on [Discord](https://discord.gg/9eqGEs56UB)
- Ask questions and share ideas in the [Github Discussions](https://github.com/orgs/autometrics-dev/discussions)
- Take a look at the overall [Autometrics Project Roadmap](https://github.com/orgs/autometrics-dev/projects/1)