Skip to content

Import dashboards, alerts and checks

If you already run Prometheus, Grafana, Alertmanager, Datadog or Uptime Kuma, you do not start from an empty page. Import reads what you have and turns it into Seylo dashboards, alert rules, notification channels, routes and uptime checks.

Import has no menu entry of its own. Open it with the Import button on Observability → Dashboards, Observability → Alerts → Rules or Observability → Uptime, which opens it on the matching source (the button is shown to a releaser and above), or from the link in those pages’ empty states. Admin → Integrations links to it as well.

Connect, then import. For Grafana, Prometheus rules, blackbox probes and Alertmanager, the first choice on each tab is a connection: the tool’s URL and a read-only key, saved once (see Connect Grafana, Prometheus and Alertmanager). Import then reads straight from the tool. Uploading an exported file is still there, under Upload a file instead, for a tool Seylo cannot reach or a file you already have.

Three rules hold for every source:

  • Nothing is written until you confirm. Every import starts with a preview, and only what you leave ticked is created.
  • Every item is accounted for. The preview says how much came across — for example 9 of 12 panels — and lists every item that did not, with the reason. A partial translation is never shown as complete.
  • No secret is copied. Webhook URLs, routing keys and API keys in the source are dropped. You type each one once, on the preview.

Importing does not change your existing tools. Prometheus, Grafana, Alertmanager, Datadog and Uptime Kuma keep running exactly as before.

Action Role
Preview a pasted or uploaded source viewer
Read from a Grafana or Prometheus connection releaser
Read from an Alertmanager connection admin
Read Prometheus rules or Probe objects from a cluster; read from Datadog releaser
Read an Alertmanager configuration Secret from a cluster admin
Import dashboards, alert rules and uptime checks releaser
Import notification channels and routes admin
  1. Open Import (see above) and choose the source’s tab: Grafana, Prometheus rules, Alertmanager, Datadog, Blackbox, Uptime Kuma or History.
  2. Choose a saved connection - for Grafana, choose Choose dashboards and tick the ones you want, or all of them. With no connection yet, the tab shows how to make one, and an admin can Connect right there. Or open Upload a file instead to upload files, paste the source, or read it from a cluster (below).
  3. For dashboards and rules, choose a cluster under Check metric names against. A panel or rule over a metric that cluster does not collect would import and then show nothing; checking says so up front. Choose Don’t check to skip it.
  4. Choose Preview.
  5. Read Coverage, the notes under each item, and the refused list. Untick anything you do not want.
  6. For alert rules, choose the cluster the rules query under Rules query. Rules are saved disabled unless you tick Enable imported rules now: an imported rule that pages someone at 3am before anyone has read it is worse than one that waits a click.
  7. For channels, type each secret the source held. A channel without its secret is unticked automatically, and a route that sends to it is disabled with the reason.
  8. Choose Import. The results link to each created dashboard, rule, channel, route and uptime check.

From a connection: choose the Grafana connection, then Choose dashboards. The list shows every dashboard the key can see, by folder; tick some or all (up to 100 per import, one request each to your Grafana) and choose Preview. Each dashboard is read over Grafana’s API and converted exactly as its exported file would be.

Grafana-managed alert rules are listed on the same preview, each on the refused list with the reason (see below), so none goes unaccounted for.

Or upload a file: export a dashboard from Grafana (Share → Export → Save to file) and upload it, or paste its JSON. Several files import together. An API export ({dashboard: ...}) and a list of dashboards are accepted too.

Panels whose queries are PromQL become Seylo panels unchanged: Seylo’s metrics store accepts PromQL. LogQL panels are rewritten for Seylo’s log store where there is a direct equivalent.

From a connection: every rule your Prometheus has loaded, read from its rules API, with each rule’s source file named on the preview. This includes rules from PrometheusRule objects and from rule files alike.

Or upload a file: a PrometheusRule manifest, a List of them, or a Prometheus rules file (groups:). Or choose Read from cluster to read every PrometheusRule in a cluster through the agent.

From a connection: Alertmanager’s running configuration, read from its status API. It is reduced to routes, receiver names and kinds and email addresses where it is read - in the agent, inside your cluster, for a connection through the agent - so no receiver URL or key reaches Seylo.

Or upload a file: an alertmanager.yaml. Receivers become channels and routes become Seylo routes. Every receiver URL and key in the file is dropped: the channel comes across with its secret fields empty, and you fill them in on the preview. See notification channels and routes.

An admin can instead choose Read from cluster, naming the namespace, the Secret and, optionally, the key that holds the configuration (for example monitoring, alertmanager-main, alertmanager.yaml). The agent reads the Secret inside the cluster and returns only routes and receiver kinds — never a credential. It needs agent 0.2.10 or later.

Monitors become alert rules, dashboards become dashboards, and HTTP synthetic tests become uptime checks. Tick which of the three to read, then choose Read from Datadog.

This reads through the agent’s Datadog connector, with keys that stay in your cluster. If the connector is off, the page shows the two commands that turn it on; see compare with Datadog.

Datadog monitors, dashboards and tests belong to your whole Datadog organisation, so only someone who sees the whole cluster can import them.

From a Prometheus connection: Seylo reads the scrape targets Prometheus actually has and finds every one whose scrape calls the blackbox exporter’s /probe with a module and a target - whether it came from a Probe object, additionalScrapeConfigs or a hand-written job. Grafana Cloud and Mimir do not list scrape targets; import from a file there.

Or upload a file: Prometheus Operator Probe objects, or a blackbox scrape configuration (jobs with metrics_path: /probe and params.module), become uptime checks on Observability → Uptime. Or choose Read Probes from cluster.

HTTP and keyword monitors become uptime checks. Uptime Kuma has no API for its monitors, so there is no connection: the Uptime Kuma tab takes a file or pasted text.

  • Uptime Kuma 1.x: Settings → Backup → Export, then upload the JSON file. It carries every setting, so each check comes across with its interval, timeout, status codes and keyword.

  • Uptime Kuma 2.x removed that export. Create an API key in Uptime Kuma (Settings → API Keys), run the command below where you can reach it, and paste the output. The key stays with you: Seylo never sees it.

    Terminal window
    curl -u :YOUR_KEY https://uptime-kuma.corp.local/metrics

    /metrics carries only each monitor’s name, type and URL, and leaves out paused monitors. Each check it creates says what to set after the import.

What comes across. A monitor’s name, URL, interval, timeout, accepted status codes and keyword, checked by the same rules as a check you type yourself. Where a value is outside Seylo’s bounds it is adjusted, with a note on the preview: Seylo checks at most once a minute and at least once an hour, and waits at most 30 seconds. Uptime Kuma’s retries become the check’s Down after: a monitor that retried once before calling itself down alerts after 2 failed checks in a row, as in Uptime Kuma. Where Uptime Kuma behaves differently - it followed redirects, ignored certificate errors, or searched the whole body for the keyword - the preview says so.

Credentials are never imported. A backup holds HTTP authentication passwords, client certificates, authorization headers and every notification’s webhook URL or token. None of them is copied, not even into a note. A check whose monitor sent a credential is imported paused, because Seylo’s checks cannot send one and the URL would most likely answer 401 or 403; the note names what was dropped by kind, such as HTTP basic authentication, never by value. Enable it only if the URL answers without one.

Notifications are listed, not imported. Each Uptime Kuma notification is on the refused list with the Seylo channel to create for it - Slack, Microsoft Teams, Google Chat, webhook, PagerDuty, Opsgenie or email - and the preview says which channels and routes to set up. Until they exist, an uptime alert does not reach the places Uptime Kuma’s notifications went, so keep Uptime Kuma running until they do. See routing uptime alerts.

Importing the same file twice creates nothing new. A monitor with the same name and URL as a check you already have is listed as already in Seylo. The preview also warns when the import would go over the 50 checks an organisation may have.

Everything below is listed on the preview with its reason, under the item’s kind, name and where it came from.

Source Not imported Why
Grafana Text, news and link panels They show text or links, not a query. Seylo dashboards hold query panels only
Grafana Visualisations Seylo does not draw Seylo draws time series, stats, bars, tables and logs
Grafana Grouped or aggregated LogQL metric queries Seylo’s log panels draw lines or one line-count series, not groups
Grafana LogQL with parsers (| json, | logfmt), label filters or formatting No direct rewrite for Seylo’s log store
Grafana LogQL stream matchers on labels other than namespace, pod and container No other Loki label maps to a field Seylo’s log collector writes
Grafana A dashboard none of whose panels could be imported Listed with its panels’ reasons
Grafana Grafana-managed alert rules They are a query plus Grafana’s own steps (reduce, math, threshold, classic conditions) that Grafana evaluates. There is no verified translation, so none is guessed. Recreate the rule in Alerts → Rules with the same PromQL and threshold, or import the Prometheus rules it came from
Prometheus Recording rules Seylo does not evaluate recording rules. Rules and panels that read one are refused too, naming it, so they can be rewritten over the raw metrics
Prometheus An always-firing rule (a “dead man’s switch”) Seylo raises its own alert when a cluster’s agent stops connecting, and shows delivery per channel
Prometheus for: longer than 1 hour Seylo’s maximum. Shorten it, or put the wait in the query, such as min_over_time(...[2h])
Alertmanager Receivers of a kind Seylo has no channel for Seylo sends to email, Slack, Microsoft Teams, Google Chat, webhooks, PagerDuty and Opsgenie / Jira Service Management. A webhook channel reaches most other tools
Alertmanager Email receivers whose to is empty or a template Seylo needs plain addresses
Alertmanager Inhibit rules Seylo has no inhibition. Use a silence with an end for a known window, or route lower-severity alerts to a quieter channel
Alertmanager Routes limited to time intervals (mute or active) Seylo routes are always active, so the route would notify outside those times
Alertmanager Routes matching on labels other than cluster, namespace, workload, alert name and severity Seylo routes match on those fields only
Alertmanager Negative matchers, and regular expressions with no exact equivalent Seylo matchers take names, * and | only. “Everything except X” grows silently as new alerts appear
Alertmanager A route with no receiver of its own Import its parent, or name the receiver on this route
Datadog Monitors other than metric monitors Seylo’s rules run PromQL over metrics and LogsQL over logs
Datadog Queries using functions, or combining metrics arithmetically Seylo converts one plain metric query at a time
Datadog Any metric outside Seylo’s verified mapping table There is no verified Seylo equivalent, and a metric outside the table is not guessed
Datadog Time aggregation other than avg() Only avg() converts exactly
Datadog Widgets other than metric time series, stats, bars and tables Seylo draws only those
Datadog Template variables other than namespace and pod Seylo has pickers for those two only
Datadog Synthetic tests other than a plain HTTP GET, or that send credentials, a client certificate, a proxy, custom headers or a body Seylo’s uptime checks are single HTTP GET requests from the Seylo server, and never copy a credential
Blackbox Modules that are not HTTP GET (TCP, ICMP, DNS, gRPC, POST) Seylo’s uptime checks are HTTP GET requests
Blackbox Probes whose targets come from service discovery Seylo needs the URLs listed. Add the public URLs as checks, or list them in the probe
Uptime Kuma Every monitor type other than HTTP and keyword: TCP port, ping, DNS, push, Docker, database, message broker, browser, JSON query, gRPC and the rest Seylo’s uptime checks are HTTP(S) GET requests from the Seylo server. The preview names what each monitor did
Uptime Kuma Groups A group checks nothing itself. Its members are listed on their own
Uptime Kuma Upside-down monitors, and keyword monitors that check a keyword is absent Seylo has no inverted check, so it would report the opposite
Uptime Kuma Monitors that send a method other than GET or HEAD A GET to an endpoint built for another method would not test the same thing. HEAD is imported as GET
Uptime Kuma Monitors with an internal or private URL Seylo’s checks reach public addresses only
Uptime Kuma Notifications Their webhook URLs, tokens and passwords are never copied. Each is listed with the Seylo channel to create instead

Dashboards and rules are definitions; history is data. Observability → Import → History covers it, and Seylo never copies history through its own servers.

You may not need to copy anything:

  • Prometheus, Thanos, Mimir or VictoriaMetrics: set the cluster’s metrics source to your store, and Seylo reads its history where it is. Nothing is copied. Until a label-enforcing proxy sits in front of it, only people who see the whole cluster can read it, because a Prometheus store cannot itself limit a query to some namespaces.
  • Datadog: turn on the Datadog connector and read Datadog in place on Admin → Integrations → Datadog; its parity report compares Datadog with Seylo’s own collection.

Seylo generates a vmctl command and a Kubernetes Job for you to run in your cluster. vmctl is VictoriaMetrics’ own migration tool; the Job copies series from your old store into the seylo-observability metrics store. Seylo never connects to the old store itself.

  1. Under Copy past metrics, choose From: Prometheus, Thanos, Mimir or VictoriaMetrics.
  2. Enter the store’s URL as the Job will reach it inside the cluster, for example http://prometheus-operated.monitoring.svc:9090. A URL with a user name or password in it is refused: the Job would carry them in plain text.
  3. Enter the Start date and, optionally, the End (today by default). Change Seylo namespace only if you installed the chart elsewhere.
  4. Choose Generate. The page shows four things to copy: the vmctl command, the Job, a NetworkPolicy that lets that one Job reach the store, and the command that removes the policy afterwards.
  5. Apply the policy, then the Job (kubectl apply -f job.yaml), and follow it with kubectl -n seylo-observability logs -f job/seylo-vmctl-backfill. Remove the policy when it finishes. The Job deletes itself a day after it ends.

Read the notes the page shows with it:

  • Backfill only the period before seylo-observability was installed. For later days both stores hold the same metrics, and sums over both would count twice.
  • Retention still applies. Samples older than the chart’s retention (30 days by default) are dropped as they arrive, so starting further back adds nothing.
  • Namespace limits still apply, through each series’ namespace label. Series without one are visible only to people who see the whole cluster.
  • How long it takes, and how much disk it uses, depend on how many series your store holds. Seylo has not measured your store, so it does not guess; vmctl prints its own progress.
  • Thanos: point the URL at something that serves Prometheus’ remote-read API, such as a sidecar’s Prometheus; Thanos Query does not serve it.
  • Mimir: the URL is the full read path, for example http://mimir-query-frontend.mimir.svc:8080/prometheus/api/v1/read.
  • If the source store has its own NetworkPolicy, it must admit pods labelled seylo.in/backfill=true from the seylo-observability namespace.
Signal Why
Logs Seylo shows log lines from when its log collector started. Who may read a log line rests on the Kubernetes fields Seylo’s collector writes (namespace, pod, container), and no export from Loki, Elasticsearch or Datadog has been verified to carry them into those names: a copied line without them would be visible to people it should not be, or to nobody. Keep the old log store read-only until its own retention runs out
Traces and APM Seylo’s traces, and the request rate, error and latency figures derived from them, start when your services send spans to Seylo’s collector. Jaeger, Tempo and Datadog APM store spans in their own formats, and the derived figures cannot be rebuilt for the past without the spans