create_monitor
ChatGPTSignals: 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 …
create_saved_search
ChatGPTSignals: 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.
detect_anomalies
ChatGPTSignals: 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.
export_resource
ChatGPTSignals: 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.
get_all_datasets_keys
ChatGPTSignals: 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_coverage
ChatGPTSignals: 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_datasets
ChatGPTSignals: 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_by_name
ChatGPTSignals: logs. Retrieve available datasets and filter them by dataset name and collection name.
get_error_summary
ChatGPTSignals: 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_key_values
ChatGPTSignals: logs. Retrieve the observed values for one key in one dataset using the top-keys data.
get_keys
ChatGPTSignals: 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_saved_searches
ChatGPTSignals: 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_usage
ChatGPTSignals: 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_webapp_link
ChatGPTSignals: 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).
run_saved_search
ChatGPTSignals: 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.
search_logs
ChatGPTSignals: 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_monitors
ChatGPTSignals: 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).
timeseries
ChatGPTSignals: 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.
validate_monitors
ChatGPTSignals: 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}]}.