Leasyd documentation

Last updated 5 October 2026

Leasyd stores and searches your logs, traces and metrics in Leasyd Vault, one store for every signal that the app, the API, PromQL, SQL and AI agents all read. You send data with OpenTelemetry, the open standard most languages and tools already support, so there is no Leasyd agent or SDK to learn and nothing locks you in.

Quickstart

1. Start a free trial: 7 days, every feature, no card. You'll get an email with a temporary password.
2. Sign in and open Get started. Pick what you're running: it shows the exact commands, with a new API key filled in.
3. Start your app with the settings shown. Data appears under Logs, Traces and Metrics within about a minute.

The settings every OpenTelemetry SDK understands:

export OTEL_SERVICE_NAME=my-service
export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.leasyd.com
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_HEADERS=x-api-key=YOUR_API_KEY

API keys

Keys are made in Settings › API keys by the account's owners. Each key has one job:

• Send data (ingest): may only send logs, traces and metrics. Safe to put in your apps' configuration: it can't read anything back.
• Read data (API): may only query, through the query API and the MCP server.

A key is shown once, when it's made: store it like a password. We keep only a hash of it. Revoke a key in Settings and it stops working within about a minute. A new key can take a minute or two before it's accepted everywhere.

OTLP endpoint

Leasyd takes OTLP over HTTP, not gRPC. For tools that only speak gRPC, run an OpenTelemetry Collector next to them and let it forward over HTTP.

Java

The OpenTelemetry Java agent instruments most frameworks with no code changes:

curl -fsSL -o opentelemetry-javaagent.jar \
  https://github.com/open-telemetry/opentelemetry-java-instrumentation/releases/latest/download/opentelemetry-javaagent.jar
export OTEL_SERVICE_NAME=my-service
export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.leasyd.com
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_HEADERS=x-api-key=YOUR_API_KEY
java -javaagent:opentelemetry-javaagent.jar -jar your-app.jar

JVM metrics (heap, garbage collection, threads) appear in Dashboards › Leasyd - JVM.

Node.js

npm install @opentelemetry/api @opentelemetry/auto-instrumentations-node
export OTEL_SERVICE_NAME=my-service
export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.leasyd.com
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_HEADERS=x-api-key=YOUR_API_KEY
export OTEL_TRACES_EXPORTER=otlp OTEL_METRICS_EXPORTER=otlp OTEL_LOGS_EXPORTER=otlp
node --require @opentelemetry/auto-instrumentations-node/register app.js

Runtime metrics (event loop, heap) appear in Dashboards › Leasyd - Node.js.

Python

pip install opentelemetry-distro opentelemetry-exporter-otlp-proto-http opentelemetry-instrumentation-system-metrics
opentelemetry-bootstrap -a install
export OTEL_SERVICE_NAME=my-service
export OTEL_EXPORTER_OTLP_ENDPOINT=https://ingest.leasyd.com
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_HEADERS=x-api-key=YOUR_API_KEY
export OTEL_TRACES_EXPORTER=otlp OTEL_METRICS_EXPORTER=otlp OTEL_LOGS_EXPORTER=otlp
export OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED=true
opentelemetry-instrument python app.py

With gunicorn or uvicorn, put opentelemetry-instrument in front of their command. Runtime metrics: Dashboards › Leasyd - Python.

Ruby

Add the OpenTelemetry gems (opentelemetry-sdk, opentelemetry-exporter-otlp, opentelemetry-instrumentation-all, and for metrics opentelemetry-metrics-sdk ~> 0.19.0 and opentelemetry-exporter-otlp-metrics), configure them at start-up with OpenTelemetry::SDK.configure { |c| c.use_all }, and set the same environment variables as above. Get started › Ruby in the app has a small file that adds runtime metrics (CPU, memory, garbage collection) for Dashboards › Leasyd - Ruby.

Other languages

Go, .NET, PHP, Rust, Erlang/Elixir and others have OpenTelemetry SDKs: see opentelemetry.io/docs/languages. Configure their OTLP/HTTP exporter with the endpoint and header above.

Linux servers

On a server (Amazon Linux 2023 or Ubuntu 22.04+, x86 or ARM), Get started › Linux server installs an OpenTelemetry Collector set up for Leasyd. It sends the server's CPU, memory, disk, network and system logs every 30 seconds (Dashboards › Leasyd - Hosts), and accepts your apps' data on localhost:4318 (HTTP) and localhost:4317 (gRPC), so apps on that server need no key.

Kubernetes

One script installs the official OpenTelemetry Collector Helm chart twice in namespace leasyd (needs kubectl and helm 3):

curl -fsSL https://app.leasyd.com/install/kubernetes/leasyd-k8s.sh -o leasyd-k8s.sh
LEASYD_API_KEY=YOUR_KEY bash leasyd-k8s.sh --cluster prod [--gpu] [--no-logs]

• One collector per node (DaemonSet): node, pod and container CPU, memory, disk and network; how close each pod is to its requests and limits; pod logs; NVIDIA GPU metrics; and your apps' OpenTelemetry on each node's ports 4317 (gRPC) and 4318 (HTTP), with the pod, namespace, node, workload and the pod labels team and app.kubernetes.io/name added.
• One collector for the cluster (Deployment): pod phases, restarts and waiting reasons (CrashLoopBackOff, OOMKilled, ImagePullBackOff), workloads' wanted and ready replicas, node conditions and allocatable CPU and memory, and Kubernetes events as logs.

The key stays in a Kubernetes Secret. The app's Kubernetes page shows nodes, workloads, pods (each with its containers, usage against limits, events, logs and traces) and what needs attention; Dashboards › Leasyd - Kubernetes and ready-made alerts (crash loops, pending pods, memory limits, nodes not ready, missing replicas) cover the rest. bash leasyd-k8s.sh --uninstall removes it all. The Helm values are public: agent.yaml and cluster.yaml next to the script.

NVIDIA GPUs

Leasyd reads NVIDIA's dcgm-exporter: in Kubernetes add --gpu to the command above (if the NVIDIA GPU Operator runs, its exporter is used; otherwise one is installed on the GPU nodes); on a server with Docker and NVIDIA's container toolkit, sudo LEASYD_API_KEY=YOUR_KEY bash collector.sh --gpu. Slurm: point DCGM_HPC_JOB_DIR at your job-mapping directory.

The GPUs page shows every GPU's utilization, memory, temperature and power; which workload and team holds it; what the fleet costs and what sits idle (held by a workload but under 5% busy) or unallocated, with recommendations; pods waiting for GPUs; hardware problems (XID errors with what each means and what to do, ECC errors, failed row remapping, thermal and power throttling); and daily peaks with the demand trend for planning. Costs use AWS on-demand list prices per GPU hour until you set your own in Settings › GPU prices. Label pods team=<name> to see spend by team.

AWS Lambda

• Metrics for every function (invocations, errors, duration, throttles): a CloudFormation template from Get started › AWS Lambda streams them from CloudWatch to https://ingest.leasyd.com/v1/aws/cloudwatch-metrics through Amazon Data Firehose. AWS bills the stream and Firehose in your account.
• Each invocation and its logs: add the OpenTelemetry Lambda layer for your runtime and set AWS_LAMBDA_EXEC_WRAPPER=/opt/otel-instrument plus the settings above.

Functions appear under AWS Lambda in the app.

Limits and answers

A request may be up to 64 MB uncompressed. Requests per second per account: 50 during the trial, 500 when subscribed (ask us for more).

Logs, traces and metrics

Logs and Traces search everything you've sent in the last 30 days: filter by service, severity, any attribute or text, and open a trace to see each span with its logs. Metrics charts any metric over time. Service map draws your services and the calls between them, from traces. Query builder and SQL answer any other question. The AI SRE can look through your data with you to explain an incident.

Dashboards and alerts

Leasyd comes with dashboards for the JVM, Node.js, Python, Ruby, hosts and AWS Lambda; any chart can be added to your own dashboards. Alerts watch a query (an error rate, a latency, a check failing) and email you when it crosses a threshold. SLOs track an objective such as 99.9% of requests under 300 ms.

Synthetic checks

Checks call your sites and APIs from AWS us-east-1 every 1, 5, 15, 30, 45 or 60 minutes:

• HTTP checks: one request or several steps (log in, then call an API with the token), with conditions on status, time, headers and body. Secrets are encrypted and never shown again.
• Browser checks: a real Chromium browser opens pages, clicks and types, and records page speed and screenshots.

Only check systems you own or are allowed to test. Up to 20 checks per account; maintenance windows pause alerts during planned work.

Drop rules

Drop rules discard data you don't need as it arrives (debug logs, health-check requests, noisy metrics), so you pay only the small ingest price for it and never the storage price. Set them in Account › Drop rules: each rule picks a signal, one to five conditions, and how much of the matching data to keep (0% drops it all; 10% keeps one in ten, whole traces at a time). The first rule a record matches decides. The page shows how much of the last 24 hours each rule would have matched before you save it. Changes apply within a minute.

Operators: = != < <= > >= in contains.

Query API

Query your data from scripts and other tools with a Read data key:

curl -s https://ingest.leasyd.com/v1/query \
  -H "x-api-key: YOUR_READ_KEY" -H "content-type: application/json" \
  -d '{"promql": "sum by (service_name) (rate(leasyd.spans{span_kind=\"SERVER\"}[5m]))",
       "start": "2026-10-05T00:00:00Z", "end": "2026-10-05T06:00:00Z", "step": 60}'

The body is one of:

• PromQL: {"promql", "start", "end", "step"} for a range, or {"promql", "time"} for one instant. Answers in the format of Prometheus' HTTP API. Besides your own metrics, PromQL sees leasyd.spans, leasyd.span.duration (a histogram) and leasyd.logs, counted from your traces and logs.
• SQL: {"sql", "start", "end"}, read-only, over the tables logs, spans and metrics.
• JSON: {"signal", "start", "end", "where", "group_by", "aggs", "search"}; the app's Query builder shows the JSON of any query you build.

A query still running after 20 seconds (or sent with "async": true) answers 202 {"job"}; ask GET /v1/query/{job} until it answers 200. Limits: 600 queries a minute, and a daily search allowance that grows with how much data a query reads (the app shows today's use in Settings).

Web monitoring (real users)

See what your visitors experience: page loads, Core Web Vitals (LCP, INP, CLS, FCP, TTFB, rated as Google does), JavaScript errors and API calls from the page that fail or are slow. It's a small script (about 4 KB gzipped) with no cookies; URLs are sent without query strings or fragments, so form data and tokens in URLs stay in the browser.

1. In the app, Settings › API keys, create a Web monitoring key and list the sites it runs on (for example https://shop.example.com). It's public by design: it can only send web events, and only from those sites.
2. Add the script to every page, before </head>:

<script src="https://app.leasyd.com/install/leasyd-rum.js" defer
  data-key="pub_..." data-app="shop-web" data-env="prod"
  data-endpoint="https://ingest.leasyd.com/v1/rum"
  data-trace-origins="https://api.example.com"></script>

Then open Explore › Web: per site, page views and visits, Core Web Vitals at the 75th percentile with the share of good visits, your pages, JavaScript errors, failing API calls and browsers. Open an error to replay that visit's events in order.

From the page to the backend. Calls to the page's own origin, and to the origins in data-trace-origins, carry a W3C traceparent header, so a failed or slow call links to the backend trace it started (your API must allow that header in CORS). Options: data-sample="0.25" keeps a quarter of visits; data-slow-call-ms="1000" sets when a call counts as slow.

If your site has a Content-Security-Policy, allow script-src https://app.leasyd.com and connect-src https://ingest.leasyd.com.

Each event is a log record of the site (service), so it's billed like any log, searchable in Logs, usable in PromQL, dashboards and alerts, and Leasyd AI can investigate it.

AI agents (MCP)

Leasyd has an MCP server, so AI agents and coding assistants can investigate your systems with you: "why did checkout get slow after 2 pm?", "show me the errors behind this trace". They get the same read-only tools as Leasyd's AI SRE: services overview, PromQL, log and span search, a whole trace, top values, SQL, synthetic checks and alerts. They can read, never change anything, and only your account's data.

Claude Code

claude mcp add --transport http leasyd https://ingest.leasyd.com/v1/mcp \
  --header "x-api-key: YOUR_READ_KEY"

Cursor

In ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
  "mcpServers": {
    "leasyd": {
      "url": "https://ingest.leasyd.com/v1/mcp",
      "headers": { "x-api-key": "YOUR_READ_KEY" }
    }
  }
}

VS Code

In .vscode/mcp.json:

{
  "servers": {
    "leasyd": {
      "type": "http",
      "url": "https://ingest.leasyd.com/v1/mcp",
      "headers": { "x-api-key": "YOUR_READ_KEY" }
    }
  }
}

Claude Desktop

In Settings › Developer › Edit config (needs Node.js):

{
  "mcpServers": {
    "leasyd": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://ingest.leasyd.com/v1/mcp", "--header", "x-api-key:${LEASYD_KEY}"],
      "env": { "LEASYD_KEY": "YOUR_READ_KEY" }
    }
  }
}

Limits: 60 tool calls a minute and 5,000 a day per account; a call that would run longer than about 25 seconds stops with a message to narrow it. Tool calls are included in the price.

Team

Invite teammates in Settings › Team; there's no charge per person. Owners manage people, API keys, drop rules and billing; members use everything else.

Billing

After the trial you pay for what you use, billed monthly in US dollars through Stripe; see Pricing. To subscribe, an owner opens Settings › Billing › Add payment details. Nothing is charged upfront: each month's invoice counts the records received, the records stored (kept 30 days) and the check runs. Usage & cost in the app shows this month so far. Manage billing changes the card, downloads invoices or cancels; a cancelled subscription stops accepting new data at the end of the period you've paid for.

Retention and deletion

Data is kept for 30 days plus the current day (UTC), then deleted automatically. Drop rules discard data before it's stored. To close your account and delete all of its data, email support@leasyd.com from an owner's address: everything is deleted within a few days.

Security

• Data is sent and shown over HTTPS only, and encrypted at rest on AWS (us-east-1).
• Each account's data is stored separately; every query runs with credentials that can only read that account's data.
• API keys are stored as hashes; check secrets are encrypted with a dedicated key.
• Leasyd stores what you send as it is: keep passwords, card numbers and other sensitive personal data out of logs and attributes (the OpenTelemetry Collector can remove or mask them before they leave your systems).

Found a security problem? Email support@leasyd.com. See also our Privacy Policy and Terms of Service.