- Brand
- Bronto
- Category
- Data & Analytics
- Primary Subcategory
- Observability, Monitoring & Incident Response
Integration details
Description
Investigate Bronto observability data, analyse logs and trends, review monitors, and create saved searches or muted monitors. This listing connects exclusively to Bronto’s EU region and is intended for customers whose Bronto account and data are hosted in Europe.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Observability, Monitoring & Incident Response
- Secondary Subcategories
- None listed
- Brand
- Bronto
- Access
- Account required
- First tracked
- 2026-11-14
- Tool count
- 19
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Bronto EU suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Bronto EU
Get updates when Bronto EU’s Discoverability Score or category rank changes.
Competing in ChatGPT Observability, Monitoring & Incident Response
View Category19 tools agents can invoke
Signals: logs, metrics. Create one or more Bronto monitors. For a SINGLE monitor, pass its fields at the top level (or a full body via `monitor`). For a BATCH, pass `monitors` — a list of up to 20 of these same argument objects — and the response is a batch summary {summary:{succeeded,failed,total}, results:[{index, status, id|error, name}]} with failures isolated per item. Every monitor is ALWAYS created MUTED (mute_until=-1) so it can be reviewed before it starts alerting; this cannot be overridden. Supply a full monitor body via `monitor` (name, queries, threshold, comparison_operator, window) for explicit control. Bronto requires name, comparison_operator, threshold, window and queries — creation is rejected up front if any are missing. no_data_status sets what the monitor reports when a window has no matching events (default OK; use ALERT to fire when a log stops arriving). Each entry in `queries` must include its own `name` (in addition to `select`/`from`/`where`); a query without a name is rejected by the backend. When asked to recommend or create monitors, consider multiple signal classes before choosing what to create: availability, error rate, performance, traffic volume, data freshness, and unusually concentrated failures. Prefer specific monitors that isolate a dataset, provider, service, route, region, or other meaningful dimension over one broad aggregate that can hide localized problems. Use get_keys and lightweight aggregate queries to confirm which signal classes are actually supported by the dataset before creating monitors. Avoid stopping at a single obvious failure class if the schema exposes other operational signals. If a signal appears useful but cannot be safely queried because of missing fields, ambiguous units, or string-typed numeric values, report it as a normalization or follow-up gap rather than fabricating a monitor. Use monitor_type to pick the kind of monitor: PATTERN (default, threshold on a query), USAGE (volume/usage alert — give a query whose select is an aggregate such as SUM(bytes_total) and the backend derives the metric automatically; no metric_id needed), CHANGE_DETECTION, or ANOMALY_DETECTION (alerts when one logs query, with no formulas, leaves its normal range: threshold is in baseline spread units, scaled MADs comparable to standard deviations, default 3; comparison_operator ABOVE, BELOW or OUTSIDE for either side, default OUTSIDE; evaluation_window is the baseline period, chosen from window when omitted; seasonality=true adjusts the baseline for the usual daily and weekly cycle, so suits metrics with a regular cycle where a fixed threshold would be noisy). Try the same settings with detect_anomalies first to see how often it would fire. A query targets logs with `from` log ids, or with `collection` + `dataset`/`datasets` (the tool builds and validates the dataset `from_expr`), OR a metric (`from_expr`: "metric_name IN ('kafka.request.queue')"). `select` can be a plain aggregate over logs (COUNT(*)) or over a metric's value — AVERAGE(value), SUM(value), MIN(value), MAX(value), and percentiles like P95(value)/P99(value). Add `groups`: ["key"] to alert PER GROUP (e.g. groups:["$service.name"] fires separately for each service) rather than on a single aggregate. Metric-based queries are validated for existence against the metric catalogue before creation (skip_validation=true to override). In a query's `where`, single-quote string VALUES and double-quote field/ATTRIBUTE names that are not simple identifiers — notably $-prefixed attributes: write "$severity_text" = 'ERROR', not $severity_text = 'ERROR' (the unquoted form builds a wrong filter and is rejected). To combine queries (e.g. an error-rate ratio), give each query a distinct `name` and add `formulas`: a list of {name, expression} where the expression references the queries by name, e.g. queries named `errors` and `total` with a formula {name: "error_rate", expression: "errors / total * 100"} — the field is `expression` (not `formula`) and `name` is required. Notifications are not caller-supplied: a single EMAIL action to you (the calling user, resolved from your principal id) is attached automatically, and creation fails if your user or email cannot be resolved (for example under API-key auth). Each query's `from` and `where` are validated as a real search first; if that combination is not a valid search, creation is rejected with an error. ai_report_instructions is the Investigation Prompt for Bronto's Investigation Reports — when the monitor fires, Bronto runs an automated investigation guided by it (e.g. "list the service's dependencies and correlate related logs"). Set dry_run=true to validate the resulting body without creating (single-monitor only). Returns the created monitor including its id.
create_monitor
Signals: logs. Create one or more reusable saved searches, optionally with a visualization. Single: pass name + search_details at the top level. Batch: pass `saved_searches` (up to 20 of those objects); the response is {summary:{succeeded,failed,total}, results:[{index,status,id|error,name}]} with per-item failures isolated. search_details mirrors search_logs (from/from_expr, where, select, and time_range or from_ts/to_ts) and adds display + groups + rollup to control how the saved view renders (chart, table, geomap, single value). When creating saved searches to support monitors, create both overview and drilldown views where useful: overview views show broad trends, while drilldowns should expose the verified dimensions needed to explain or localize an alert. Do not assume common field names across datasets; call get_keys per dataset and only build views from verified fields. Returns the created search(es) with id. Use get_saved_searches to inspect existing ones.
create_saved_search
Signals: none. Summarise usage of your org's datasets on two activity axes: ingestion (is data still arriving?) and search (is anyone querying it?). Returns a `summary` — per-axis counts (active/inactive), exact bytes, and the org max `limit` (a per-calendar-month quota, so compare against `bytes` over a month-to-date window; reading limits needs permission — if denied the `limit` is dropped and a top-level `limits_unavailable` note is set) — plus a `datasets` list. Each dataset carries log_name, log_id, per-axis bytes, and last_heartbeat_at (last time data arrived); minimal_output=false adds per-axis events/count and period-over-period delta_factor, `status` (ingest_inactive/search_inactive/active), tags, and parser/modified/system metadata.
get_usage
Signals: logs. Find anomalies in a metric derived from logs (metric/time-series anomalies only, not log patterns). Returns episodes — runs of consecutive unusual windows — with when, direction, severity, peak value, expected value and band, per group. Each window is scored against a rolling baseline of the preceding windows. Use after timeseries shows something odd, or to answer 'when did this go wrong'. With seasonality 'compare' each episode says whether the usual daily/weekly pattern explains it (explained_by_seasonality); seasonality only applies once a seasonal profile has been trained, otherwise the response reports PROFILE_GENERATING and scores without it. One metric per call. Counts towards search usage limits.
detect_anomalies
Signals: logs. Execute an aggregate query that returns totals, grouped results, or time-series data from log data. Use this for counts, rates, grouped summaries, and trend analysis before fetching raw events. Bare words in search_filter perform full-text matching across the event. Field predicates only match exact fields; call get_keys before using a field name unless it came from the user or a saved search. For field-specific matches, copy the exact field spelling from get_keys and quote dotted or hyphenated field names, for example "Nested.Field-Name"='req-8f3a1c2d'. If an exact-field aggregate returns zero, recheck the field spelling with get_keys before reporting zero. Response shape: each group in timeseries has a 'count' field (matching event count, not a byte value) and a 'value' field (the numeric aggregate result for your metric, e.g. SUM of bytes). Use 'value' as the answer for byte/numeric metrics; do not report 'count' as a byte total.
timeseries
Signals: logs. Execute a query that returns matching events from log data. For investigation, prefer a small limit first, then expand only if needed. Bare words in search_filter perform full-text matching across the event. Field predicates such as "field"='value' only match that exact field; call get_keys before using a field name unless the field came from the user or a saved search. For trace ids, request ids, or other opaque-identifier investigations, start with a bare full-text word search unless the user explicitly asks for a field-specific match. When the user does ask for a field-specific match, copy the exact field spelling from get_keys and quote dotted or hyphenated field names, for example "Nested.Field-Name"='req-8f3a1c2d'. If that exact-field query returns zero, recheck the field spelling with get_keys before reporting zero.
search_logs
Signals: none. Export a Bronto resource as infrastructure-as-code text, ready to paste into an existing Terraform project. Use when: the user wants to add an existing dashboard, monitor, user, group, SSO identity provider, or Slack/webhook/provider integration to an IaC project and already has, or can resolve, its resource_id. Don't use for: resources without a resource_id yet - resolve a monitor's first with search_monitors, and ask the user for any other resource's id; widgets and metric definitions have no export of their own, only as dependencies inlined into a dashboard or monitor export. Returns: the raw export body as plain text (Terraform/OpenTofu HCL), not JSON-wrapped. Notes: "terraform" and "opentofu" currently produce identical HCL output for every resource_type; pick whichever matches the user's toolchain.
export_resource
Signals: logs. Retrieve available datasets and filter them by dataset name and collection name.
get_datasets_by_name
Signals: logs. Report how well each dataset is covered across three axes: monitored (watched by a monitor), searched (queried by anyone), and ingesting (still receiving data). Read-only. The one call that answers "what is watched, used, and alive — and what is a blind spot?" Always returns a `datasets` list. Each item carries: `monitors` (the ids of monitors covering it; [] means unmonitored), `search` {active, bytes}, and `ingestion` {active, bytes, last_heartbeat_at}. A dataset that ingests but has monitors:[] and search inactive is a live blind spot. The search/ingestion axes come from the usage API; if you lack billing access they degrade to an `unavailable` note (a top-level `usage_unavailable` is also set) rather than failing the call. METRICS are the RAW ingested catalogue (every OTEL metric Bronto receives — e.g. kafka.request.queue), NOT the definition list, so metrics that have no monitor/definition still appear (as unmonitored). A metric is monitored when a monitor's metric definition selects it by name. Use filter="kafka*" to answer "which kafka metrics are we watching?". DETAIL: • minimal_output=true (default) — each dataset with monitors (bare ids), search and ingestion axes, plus a `coverage` rollup {total, groups} grouped by collection (or group_by tag). • minimal_output=false — adds per-dataset tags, monitor {id, name} instead of bare ids, and the metrics lists (monitored_metrics, unmonitored_metrics). Coverage is computed from monitors + datasets + usage + the raw metric catalogue. To see which monitors cover a resource, use search_monitors. include restricts to logs or metrics only. ATTRIBUTE KEYS (full detail): pass resolve_keys=true with minimal_output=false to enrich each log and metric with the attribute keys it carries (Resource:service.name, Resource:host.name, ...). Logs use one bulk call for the whole org; metrics have no bulk endpoint, so they cost one call per metric in the lists, limited by max_key_lookups (keys_truncated indicates the limit was reached; set 0 for unlimited). Use key_names to keep only matching keys (case-insensitive substring, e.g. key_names=["service"] surfaces only Resource:service.name).
get_coverage
Signals: logs. Use this first when investigating errors/warnings, especially over a broad time range. A first-pass triage step that narrows down where the errors are before you run a broad search: it returns org-wide error & warning totals plus a per-dataset breakdown, so you learn which datasets are affected, then drill into only those (their log_id is in by_dataset) with search_logs/timeseries instead of scanning everything. Backed by a precomputed status-analytics path: it does NOT consume search quota, so it is safe to run first over wide windows. by_dataset lists ONLY the datasets that actually have errors/warnings (the backend omits clean datasets), each {log_id, name, collection, errors, warnings} sorted by volume — name/collection are resolved from the datasets catalogue (null if the log_id isn't found). Optionally returns a per-bucket series. Returns {errors, warnings, series?, by_dataset?}. Read-only.
get_error_summary
Signals: logs. Retrieve saved searches available to the authenticated Bronto user. Provide saved_search_id to fetch one saved search with its query configuration; omit it to list available saved searches. Optional search parameters can filter the list by text query, tags, arbitrary key, or arbitrary value.
get_saved_searches
Signals: logs. Retrieve the most frequently occurring keys for a specific dataset, grouped under the parser-recorded data type: {"STRING": [name, ...], "NUMBER": [...], ...}. Use this before constructing field-specific filters unless the exact field came from the user or a saved search. Copy returned names exactly; quote dotted or hyphenated field names in search_filter, e.g. "Nested.Field-Name"='value'. Use the type to build the predicate: NUMBER/boolean comparisons use the bare unquoted literal (field >= 500); STRING values use single quotes ('value'). Aggregates like SUM/AVG/percentiles apply to NUMBER fields only.
get_keys
Signals: none. Get a URL/deep link to navigate to a specific page in the Bronto web app UI. Prefer the `webapp_url` already returned by search_telemetry, aggregate_telemetry, search_logs, timeseries, create_monitor, and create_saved_search when linking to what one of those just did — use this tool only for pages not tied to another tool's output. Pass `page` and the ids it needs: search (optionally preset the query with search_filter/time_range/etc. below; omit them to open Search with no query preset), monitors_list (optional monitor_id to deep-link to one monitor), monitor_create, monitor_edit (requires monitor_id), dashboards_list (optional dashboard_id to deep-link to one dashboard), dashboard_widget_create (requires dashboard_id), dashboard_widget_edit (requires dashboard_id, widget_id), add_data (the data source picker for connecting a new dataset), parser_view (requires parser_id).
get_webapp_link
Signals: logs. Retrieve the most frequently occurring keys across all accessible datasets, keyed by log_id, each dataset's keys grouped under the parser-recorded data type ({"STRING": [name, ...], "NUMBER": [...]}). Schemas differ across datasets, so resolve fields per dataset.
get_all_datasets_keys
Signals: logs. Retrieve the observed values for one key in one dataset using the top-keys data.
get_key_values
Signals: logs. Retrieve the available logs as MCP datasets. Each dataset carries `last_heartbeat_at` (ms epoch of last ingest, or null) and `active` — true when it ingested within the recency window (14 days by default). A null heartbeat is treated as dormant (the field was added recently, so absence means at least ~14 days stale). Use `active`/`last_heartbeat_at` to pick which logs to scope a search to: a log dormant for longer than your query window can't contain matches, so focus discrete searches on active logs when the window is within the recency window.
get_datasets
Signals: logs. Execute a saved search by id, so a saved query can be re-run without rebuilding it. Returns exactly what running the query directly returns: an event search comes back identical to search_logs (events), an aggregate/grouped one identical to timeseries (groups_series/totals) — the tool just picks the right one from the saved query. Pass time_range (or from_ts/to_ts) to run over a different window than it was saved with; limit caps rows. Use get_saved_searches to find the id.
run_saved_search
Signals: logs, metrics. Search, filter, and inspect Bronto monitors. Without monitor_id, search monitors by a case-insensitive substring query and/or status. With monitor_id, inspect that monitor. By default this returns compact monitor identity/status. Set minimal_output=false to return full monitor objects, embed recent event history, and include the monitor's query definition (the backing queries and formulas) for a direct monitor lookup. Events indicate what triggered the monitor: status transitions (previous_status -> status) with a unix-ms time and message, newest first. For group-by monitors, the per-group detail is carried in each event's group_status_transitions. Bound the events by from_ts/to_ts (unix epoch ms) and limit how many are returned with limit (defaults to 20).
search_monitors
Signals: logs, metrics. Health-check EXISTING Bronto monitors: confirm each is backed by a working query, and whether it has data. For each monitor, its backing metric definition is resolved and that query (from log ids / from_expr + where) is run as a count(*) over the last 24 hours. status separates 'fix this' from 'wait for data': error = the monitor can't fire as built (no resolvable metric definition / orphaned, or a genuinely malformed query); warn = the query is VALID but has no data to act on — either zero events in the window, OR its target dataset/metric isn't present in this org yet (e.g. a from_expr metric collection that hasn't started flowing) — the monitor will fire once data arrives; ok = data present. So an erroring monitor needs fixing; a warn needs data. signal carries events_in_window, target_present (false when the dataset/metric is absent), and window. Read-only. Validates ALL monitors by default; pass monitor_ids to check specific ones. Returns {summary: {ok, warn, error}, results: [{monitor_id, name, status, reason, signal}]}.
validate_monitors
Bronto EU ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Bronto EU's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Bronto EU alternatives on ChatGPT?
As of 2026-11-15, Bronto EU competes with API Status Check, Averth, Better Stack, Biggy, Birdie, bitdrift, Checkly, ClickStack and 27 more in ChatGPT Observability, Monitoring & Incident Response, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.


