# StarRocks

The **StarRocks** page connects to one frontend (FE) of a cluster over SQL, the way a MySQL client does, and reads what the cluster reports about itself: which nodes are up, which loads failed, what is running now, how big the tables are and how far compaction is behind. It also reads each node's metrics port for live charts, and the node's log files over Session Manager.

The session is **read only**. ARNscope never runs DDL, grants, loads or settings changes for you. The two actions that change something, **Stop query** and **Add forwards and restart**, each ask first (see [What changes something](#what-changes-something)).

## Add a cluster

1. Open **StarRocks**, choose the profile and region in the title bar, and click **Add cluster** (the + in the **Clusters** pane).
2. Fill in:
   - **Host**: a frontend's address, and **Port**: its query port, usually `9030`.
   - **Connect through**: **ARNscope tunnel** (a saved [SSM tunnel](https://arnscope.com/docs/ssm-tunnels) to the FE), **My own tunnel** (a local port you forward yourself) or **Direct**.
   - **User** and the password, from a **Secrets Manager** secret or typed in (**Enter password**).
3. Save, select the cluster and click **Connect** (or **Start tunnel and connect** when its tunnel is stopped).

StarRocks has no IAM login, so a cluster saved with IAM shows "StarRocks has no IAM login. Edit this cluster to use a Secrets Manager secret or a typed password." We recommend a Secrets Manager secret: ARNscope reads it with your AWS profile when you connect, so access stays under IAM and no password is stored in the app. A typed password lasts for that session only.

A cluster saved without an AWS profile shows under every profile and region.

### Which user to connect as

Any StarRocks user can connect. `root`, or a user with `OPERATE ON SYSTEM`, sees everything; other users see fewer views.

If you would rather not keep an admin login in ARNscope, open **Optional: a read-only observer user** on the connect panel. It shows SQL for a user that can look but not change anything, with the user name you type (default `arnscope_observer`). ARNscope never runs it. Run it yourself as an admin, in your own client or a write-mode Query console, and keep the password in a Secrets Manager secret (`username`/`password`):

```sql
CREATE USER IF NOT EXISTS 'arnscope_observer'@'%' IDENTIFIED BY '<password>';
GRANT OPERATE ON SYSTEM TO USER 'arnscope_observer'@'%';
-- Optional: task_runs only lists databases the user holds a privilege on.
-- This also lets the user read every table; leave it out if you only need the cluster views.
GRANT SELECT ON ALL TABLES IN ALL DATABASES TO USER 'arnscope_observer'@'%';
```

`OPERATE ON SYSTEM` is what lets `SHOW FRONTENDS`, `SHOW BACKENDS`, `SHOW COMPUTE NODES` and the `SHOW PROC` views run. Table queries are not part of this page; they live in the Databases page's Query console.

## The header

| Item | Meaning |
| --- | --- |
| Cluster name | Click to copy it. Right-click to copy `host:port` or the host. |
| **Connected** | The read-only session is open. |
| Access chip | What this user can see. **Full access**, **Limited · N views need a grant**, **Limited · N views unavailable** or **Not StarRocks**. Click it to open **Access**. |
| **Disconnect** | Closes the session. Changing profile or region, or picking another cluster, also closes it. |
| **Version** | The server's `current_version()`. "Not StarRocks" when it did not answer: the server is not StarRocks or not reachable. |
| **User** | The StarRocks user you connected as. |
| **Session** | Always **Read only**. |

### Access

The **Access** dialog runs a capability check: one harmless statement per source, and lists each view as **OK**, **Needs OPERATE ON SYSTEM** or **Unavailable**, with the server's error. When a grant is missing it shows the exact statement for your user (`GRANT OPERATE ON SYSTEM TO USER '<you>'@'%';`) with **Copy grant**.

| View | Needs |
| --- | --- |
| Health, Nodes, Errors | `SHOW FRONTENDS` and `SHOW BACKENDS` (`OPERATE ON SYSTEM`) |
| Loads | `information_schema.loads` (StarRocks 3.1 or later; lists only loads into tables this user can access) |
| Queries | `SHOW PROC '/global_current_queries'` (`OPERATE ON SYSTEM`) |
| Storage | `information_schema.partitions_meta` (StarRocks 3.x; lists only tables this user can access) |

**Optional sources** are shown as chips, marked "· off" when this user cannot read them or the version lacks them: Compute nodes, Routine loads, Load history, Task runs (24h), Query profiles and Tablet health (`SHOW PROC '/statistic'`, needs `OPERATE ON SYSTEM`). A view still opens without its optional sources; the parts they feed show "n/a" or a note.

A failed check is not kept: after you add a grant, **Refresh** on the tab (or **Run the capability check again**) picks it up without reconnecting.

## How reading works

- Nothing is read until you open a tab on a connected cluster. After that, a tab only reads again when you click its **Refresh**. There is no auto-refresh, except the live metrics, which you can pause.
- Statements run one at a time on the one session.
- Each tab says when it was read: "Read at 14:02 (this Mac)".
- Each statement returns at most 1,000 rows or 1 MiB. When a result was cut off, the tab says "Some results were cut off at the per-statement limit (1,000 rows or 1 MiB), so this view may be incomplete."

### Server times and your time zone

StarRocks writes its times on the cluster's own clock. ARNscope works out that clock's UTC offset once per session from `SELECT now()`, rounded to 15 minutes so a little drift or network delay does not matter, and converts every server time to the time zone you chose for the app (the zone chip in the title bar, or **Settings → Time zone**). So the **Errors** list, **Created**, **LastHeartbeat**, load start times and query start times all read on the same clock as the rest of ARNscope.

| Where | What you see |
| --- | --- |
| A converted time | Your chosen zone, 24-hour. Hover it for the value as the server wrote it, for example "Server wrote: 2026-11-12 20:36:58 (UTC+00:00)". Column headers say which zone, for example "Kolkata time, converted from the server clock (UTC+00:00)". |
| Copying a time | ISO 8601 with the shown zone's offset, for example `2026-11-13T02:06:58+05:30`. Export CSV writes UTC (`…Z`). |
| "Today" in the **Errors** list | Today in your chosen zone: a time from today shows only the clock, an older one shows the date ("Nov 12, 17:37"). |
| "Read at …" | When ARNscope read the data, in your chosen zone; hover for the date and zone. |
| "(server)" in a column name, for example **Created (server)** | Only when the server's clock did not answer: those times are shown exactly as StarRocks wrote them, unconverted. |
| Logs tab | The file list follows your zone. Log lines keep the node's own time zone (often UTC) and are never rewritten. |

If the cluster's own zone changes for daylight saving during a long session, converted times can be an hour off until the offset is read again, which happens when you reconnect to the cluster. The load "nights" on the Loads tab follow the server's date.

## Tabs at a glance

The tab names carry a short warning when something needs a look:

| Tab label | Shows when |
| --- | --- |
| **Overview · N errors** | The error list has entries. |
| **Loads · N cancelled** | Loads were cancelled in the last 24 hours. |
| **Queries · N slow** | Queries have been running for over 30 s. |
| **Storage · compaction N** | The worst partition's compaction score is above 100. |
| **Nodes · N down** | Nodes report `Alive` false or an `ErrMsg`. |

## Overview

### Health tiles

Each tile links to the tab that explains it.

| Tile | What it means | Healthy | When to worry |
| --- | --- | --- | --- |
| **Frontends alive** | Frontends answering, out of all frontends. The detail names the leader. | All alive, a leader named. | Any frontend down (red), or "No leader reported": the cluster cannot accept DDL or loads without a leader. **Show nodes** to see which one and its `ErrMsg`. |
| **Backends and compute nodes alive** | Backends (BE) and compute nodes (CN) answering, with how many of each. | All alive. | Any down (red): queries and loads lose that node's capacity, and its tablets lose a replica. Zero nodes at all is amber. |
| **Versions** | How many different StarRocks versions the nodes run. | 1. | More than 1 (amber): a rolling upgrade is in progress or stalled. The detail lists them. |
| **Nodes reporting ErrMsg** | Nodes whose `ErrMsg` column is not empty, with their addresses. | 0. | Any (red). Usually a missed heartbeat; the error text is in the Errors list and on the Nodes tab. |
| **Paused routine loads** | Routine loads (continuous loads, typically from Kafka) in state `PAUSED`. | 0. | Any (amber): that stream is not loading. The reason is in the Errors list. StarRocks pauses a routine load, for example, after too many bad rows. Fix the cause, then an admin resumes it (`RESUME ROUTINE LOAD`). **Show routine loads** filters the Loads tab. |
| **Failed MV task runs (24h)** | Task runs (materialized view refreshes and submitted tasks) in state `FAILED` in the last 24 hours. | 0. | Any (amber): a view may be stale. **Show failed runs** filters the Errors list. |
| **Cancelled loads (24h)** | Loads in state `CANCELLED` in the last 24 hours. StarRocks reports a failed load as `CANCELLED`. | 0. | Any (amber): data from that load is missing. **Show cancelled loads** opens them on the Loads tab. |
| **Running queries** | Queries running now, the same list as the Queries tab. | Few, none for long. | Any running over 30 s turns it amber ("N over 30 s"). |
| **Queries running on backends** | Shown instead when this user cannot read the running-query list: the sum of each backend's `NumRunningQueries`. This counts query fragments on backends, not frontend queries. | | Use it only as a rough load signal. |
| **Worst partition compaction score** | The highest compaction score of any partition, and which partition. See [Compaction score](#compaction-score). | Under 10. | 10 to 100 is amber (building up); above 100 is red. **Show storage**. |

"n/a" means the source is not available to this user or on this version.

### Errors

One list, newest first, from four sources:

| Source | What it lists |
| --- | --- |
| **node** | Nodes with an `ErrMsg`, timed by their last heartbeat. |
| **routine load** | Routine loads that are paused or cancelled now, with the reason StarRocks recorded. |
| **load** | Loads cancelled in the last 24 hours, with their error message. |
| **task run** | Task runs that failed in the last 24 hours, with their error code and message. |

The routine load, load and task run sources return at most 200 rows each. Use the **Source** chips to filter. Click a row to see the full message and the statement it came from ("From"), with **Copy statement**. If a source could not be read, a note says which one and why. With nothing to show: "No errors found".

### Live

Below the errors, **Live** reads each node's metrics port (the `HttpPort` the node reports) and charts the cluster.

| Tile | What it means | Healthy | When to worry |
| --- | --- | --- | --- |
| **CPU (average)** | Average CPU use of the backends and compute nodes. | Has headroom for your peaks. | Pinned near 100 % for long: queries queue and slow down. Look for heavy queries on the Queries tab. |
| **Process memory** | Memory used by the backend and compute node processes, summed. | Steady. | Climbing without coming back down, or near the machines' memory: queries may fail with memory errors. |
| **Queries per second** | Queries per second, across all frontends. | Your usual level. | A sudden drop to 0 (clients cannot reach the cluster) or an unexpected spike. |
| **Errors per second** | Failed queries per second, across all frontends. Amber when above 0. | 0. | Any sustained rate. The Queries tab and the Logs tab show what is failing. |
| **p99 latency** | The 99th-percentile query time, in ms, of the slowest frontend: 99 % of queries finish faster. | Steady at your usual level. | Rising: a few queries are getting slow. Often comes with high compaction scores or high CPU. |
| **Disk available** | Free disk space on the backends and compute nodes, summed. | Plenty, and not shrinking fast. | Falling quickly or near zero: loads will fail when disks fill. |
| **Tablet compaction score (node)** | The worst compaction score any node reports right now. The line at 100 on its chart marks the danger level. | Under 10. | Above 100 (red); 10 to 100 is amber. **Show storage** to find the partition. |

Six charts follow: CPU % (BE and CN average), process memory (GiB), queries and errors per second (errors on their own right-hand axis, since they are usually far fewer), p99 latency, compaction score (worst node, with the 100 line) and disk available. A chart shows from the first reading; rates (per second) need two readings.

- **Updating every 10 s**: choose 5, 10 or 30 s. **Pause updates** stops reading; the figures dim because they are the last reading, not the current one. "slower while nodes answer slowly" means ARNscope stretched the interval because nodes took long to answer.
- Updates run only while the Overview or Nodes tab is on screen, the page is shown and the window is visible. They stop when you leave the tab. While they run over a tunnel, the tunnel's 10-minute idle stop is held off.
- ARNscope keeps about one hour of points (360 per node per series), reads at most 32 nodes, four at a time, and waits at most 5 s for each node.

**Live routes** (collapsed, for example "Live routes · 2 of 8 unavailable") lists the nodes without charts and why:

| Chip | Meaning |
| --- | --- |
| **Live** | The node answered ("Answered in 41 ms"). |
| **Waiting** | No answer yet. |
| **No route** | "The tunnel has no forward to host:port." See below. |
| **Down** | "The cluster reports this node down, so it is not asked." |
| **Unreachable** | The node or the route failed; the reason is shown. |

Live charts need an ARNscope tunnel or a direct connection. A **My own tunnel** (local port) route reaches only the query port, so the page says "Live charts need an ARNscope tunnel or a direct connection."

When the cluster's tunnel has no forward to the nodes' metrics ports, the page offers **Add forward and restart** (or **Add forwards and restart**). It adds a forward for the FE leader and one backend or compute node (pick it with **Node to watch**; the others stay without charts). If the tunnel runs on the node's own instance, it adds each missing local port instead. The prompt names each `host:port`, how many SSM sessions that uses, and that "The tunnel restarts, so open connections and queries on it end, and this page reconnects." **Not now** dismisses it. With no free SSM session it says so and asks you to stop another tunnel first.

## Loads

From `information_schema.loads`: every load into tables this user can access, as far back as StarRocks keeps them ("Your tables only; old loads are pruned").

### Summary by database

The top four databases by number of loads over the last 7 days (routine loads are left out of the counts, since they run continuously; "+N routine loads" says how many there were):

- **Verdict**: "7 of 7 nights OK" when the database loaded on at least 4 of the 7 days; otherwise "3 loads in 7 days" (plus ", cancelled" or ", N cancelled"). For a nightly database the verdict is red when a night had a cancelled load and amber when a night has not finished; otherwise it is amber when a load was cancelled.
- **last run**: the start time (server clock) of the newest night's loads, the night's state, rows loaded, rows filtered (amber) and how long it took.
- **Dots**, one per night, oldest first, by the server's date: green "all finished", amber "a load was cancelled", blue "still running", hollow "no loads". Hover a dot for the date and number of loads.
- **Show runs** filters the table to that database for 7 days and selects the run the line quotes.

### Filters and table

**Range** (1, 3 or 7 days), **Type**, **State** and **Database**, with **Clear filters**. The table starts on the most-loaded database and its usual load type. It shows the newest 500 loads; narrow the filters to see older ones.

| Column | Meaning |
| --- | --- |
| **Created (server)** | When the load was submitted, server clock. |
| **Table** | `database.table`. |
| **Type** | `INSERT` (INSERT INTO … SELECT), `BROKER` (Broker Load, for example from S3), `STREAM` (Stream Load over HTTP) or `ROUTINE` (Routine Load). |
| **State** | See below. Cancelled rows are tinted amber. |
| **Rows** | Rows written to the table. |
| **Filtered** | Rows rejected for bad data (amber when above 0). |
| **Duration** | Finish time minus start time (or created time). "—" while running. |
| **Queued** | Start time minus created time: how long it waited to start. Long waits mean the cluster is busy with other loads. |
| **User**, **Label** | Who ran it, and its label. |

| State | Meaning |
| --- | --- |
| `PENDING`, `QUEUEING` | Submitted, waiting to start. |
| `LOADING` | Reading and writing data. |
| `PREPARING`, `PREPARED`, `COMMITED` | Finishing the transaction (`COMMITED` is StarRocks' spelling). The data is not visible yet. |
| `FINISHED` (green) | Done; the data is visible. |
| `CANCELLED` (amber) | Failed or cancelled; nothing from this load was kept. The error says why. |

**Cancelled vs failed**: a load never says "failed". StarRocks reports a failed load as `CANCELLED` and puts the reason in its error message. Task runs (materialized view refreshes) do say `FAILED`. Routine loads say `PAUSED` (stopped, can be resumed) or `CANCELLED` (stopped for good).

Select a load for its details: **Copy label**, **Copy load ID**, **Open profile** (when it has one), the **Error** ("No error recorded." when there is none), and the **Tracking SQL**, the statement that returns the rejected rows. **Open in Query console** puts it in the Databases page's Query console for this cluster without running it. The server records tracking SQL only for loads that filtered rows. The details also list created, started and finished times (server clock), rows loaded, filtered and unselected (dropped by the load's own `WHERE`), rows and bytes scanned, and progress.

## Queries

### Running queries

From `SHOW PROC '/global_current_queries'`, the queries running on every frontend, longest first, with the SQL text from `SHOW FULL PROCESSLIST`. ARNscope's own statements are left out.

Each row shows how long it has run (amber and tinted over 30 s), user, database, memory, data and rows scanned, the frontend, and the query ID (**Copy**). Long SQL shows three lines with **Show full SQL**. "SQL text not visible: another user's session or another FE." means the processlist did not include that connection. **Copy SQL** and **Open in Query console** (without running it) are under the SQL.

A query running over 30 s is not wrong in itself: big reports and loads take minutes. Look at memory and data scanned to judge whether it is the one slowing everything else down.

### Stop query

**Stop query** is the one action on this page that changes the cluster, and it asks first:

1. ARNscope checks on a second connection that the query is still running ("Query 7f3c1a2b… is no longer running." if not).
2. A native dialog, **Stop query?**, names the query, who runs it, on which database and for how long. If the query is a load (an `INSERT`), it adds that stopping it "leaves the target table without this run's data until it is re-run". It ends: "Stopping it cancels the work done so far. This can't be undone." Buttons: **Stop query** and **Keep running**.
3. Only after **Stop query** does ARNscope send `KILL QUERY '<id>'`, once. The row shows **Stop requested**, and the list is read again every 2 s (at most 10 times) until the query is gone.

An unanswered dialog expires after a minute and the query keeps running. One stop dialog is open at a time. Stopping another user's query needs `OPERATE ON SYSTEM` ("Needs OPERATE ON SYSTEM to stop other users' queries."). Every attempt, including cancelled ones, goes to the local activity log with the query ID, whose query it was and the outcome, never the SQL. Stopping a query needs the desktop app.

### Profiles

Up to 100 query profiles (`SHOW PROFILELIST LIMIT 100`): **Started (server)**, **Time**, **State** (Finished, Error, Running), **Query ID** and **Statement**. Click a row or press Enter to read its raw profile in a read-only viewer, with a summary line such as "Total 41 s · planner 182 ms · peak memory 3.8 GB". **Copy profile**, **Close (Esc)**. A profile larger than 1 MiB is cut off.

"No query profiles. Profiling is off, so slow queries aren't recorded." means the cluster does not keep profiles. The page shows the statement an admin can run to record queries over 30 s, with a copy button; ARNscope never runs it, and only new queries are profiled:

```sql
SET GLOBAL big_query_profile_threshold = '30s';
```

## Storage

From `information_schema.partitions_meta`, tables this user can access, largest first (at most 500).

| Tile | What it means | Healthy | When to worry |
| --- | --- | --- | --- |
| **Total size** | Size of the listed tables. "approximate" when the cluster does not report exact sizes and ARNscope adds up the text sizes instead. | | Growth you did not expect. |
| **Largest table** | The biggest table and its size. | | |
| **Worst partition compaction score** | The highest compaction score, with its partition. | Under 10. | 10 to 100 amber, above 100 red. |
| **Unhealthy or inconsistent tablets** | Tablets (the pieces a partition is split into, each stored as replicas on several nodes) that are missing or have a bad replica, plus tablets whose replicas disagree, out of all tablets. From `SHOW PROC '/statistic'`. | 0. | Any (red). Right after a node goes down this is expected while StarRocks repairs the replicas; if it stays above 0 after the node is back, check the Nodes tab and the backend logs. |

Tablet health needs `OPERATE ON SYSTEM`; without it the page says so with **Open Access**.

The table lists **Database**, **Table**, **Partitions**, **Rows**, **Size** and **Max compaction score** (rows above 100 tinted red). Click a table, or press Enter, for its partitions:

- **Model and keys**: **Model**, **Primary key**, **Sort key**, **Partition key**, **Distribution** and **Buckets**, from `information_schema.tables_config`.
- **Partitions**, worst compaction score first (at most 1,000): **Partition**, **Range** (a one-day range shows as its date), **Buckets**, **Rows**, **Size**, **Avg score**, **P50 score**, **Max score** (100 or more tinted red), **Visible ver.** (the newest version queries read), **Compacted** (the version compaction has merged up to) and **Version time (server)**.
- **Copy table name**, **Open in Query console** with `SHOW PARTITIONS FROM` the table (not run), **Copy SHOW PARTITIONS statement**, **Close (Esc)**.

### Compaction score

Every load into a StarRocks table writes a new small batch of data (a version). Queries have to read and merge all the batches that have not been compacted yet. Compaction runs in the background and merges them into fewer, larger files. The compaction score measures how much merging is waiting: roughly how many un-merged batches a query has to read.

| Score | ARNscope shows | Meaning |
| --- | --- | --- |
| Under 10 | Normal | Compaction keeps up. |
| 10 to 100 | Amber | Building up. Watch it. |
| Above 100 | Red | "Writes are outpacing merges, and queries slow down." |

The usual cause is many small, frequent loads into the same partitions, faster than compaction can merge them. What helps: load less often in bigger batches, check that the backends are healthy and have spare CPU and disk, and find the hot partition here (the partition list sorts worst first). A **Compacted** version far behind the **Visible ver.** means compaction is lagging on that partition.

The partition score (Storage, Overview tile) comes from `partitions_meta`. The node score (Live) comes from each node's metrics: the frontend leader's maximum tablet score, and on backends the worse of their base and cumulative compaction scores. Both use the same thresholds.

## Nodes

Three tables, exactly as `SHOW FRONTENDS`, `SHOW BACKENDS` and `SHOW COMPUTE NODES` return them, so a newer version's extra columns still show. `Alive` and `ErrMsg` are moved right after the node's address. Rows that are down or erroring are tinted red, and the table heading says "N down or erroring". Time columns are marked "(server)". A cluster in shared-data mode runs compute nodes instead of backends, so "No backends" is normal there.

| Column | What it means | Healthy | When to worry |
| --- | --- | --- | --- |
| `Alive` | The leader hears this node's heartbeat. | `true` | `false`: the node is down or unreachable. |
| `ErrMsg` | The last heartbeat error. | Empty | Any text, for example a heartbeat timeout. Open the node's logs. |
| `LastHeartbeat` | When the leader last heard from it (server clock). | A few seconds ago. | Minutes old. |
| `Role` (frontends) | `LEADER`, `FOLLOWER` or `OBSERVER`. | Exactly one `LEADER`. | No leader. |
| `Version` | StarRocks version on that node. | The same on every node. | Mixed versions outside an upgrade. |
| `TabletNum` | Tablets stored on the node. | Similar across nodes. | One node far above the others (uneven data). |
| `UsedPct`, `MaxDiskUsedPct`, `AvailCapacity` | Disk use. | Room to grow. | Close to full: loads fail when disks fill. |
| `NumRunningQueries`, `CpuUsedPct`, `MemUsedPct` | Current load on the node. | Your usual level. | One node much busier than the rest. |
| `SystemDecommissioned`, `ClusterDecommissioned` | The node is being removed. | `false` | `true` when you did not plan it. |

Below the tables, **Live per node** charts each node separately (one line per node): CPU %, memory (process memory on backends and compute nodes, JVM heap on frontends), queries and query errors per second, p99 latency, tablet compaction score (with the 100 line) and disk available. **Live routes** is open here and lists every node with how it is reached.

## Logs

The **Logs** tab reads a node's StarRocks log files (such as `fe.log`) from `/var/log/starrocks/fe`, `/var/log/starrocks/be` or `/var/log/starrocks/cn` on the node's EC2 instance, over Session Manager, with the same machinery as [EC2 Files](https://arnscope.com/docs/ec2-files). It is read only and confined to those folders.

1. **Node**: pick one (grouped by Frontends, Backends and Compute nodes; nodes that are down are dimmed).
2. ARNscope finds the node's instance:
   - When the cluster's tunnel runs on the node's own instance, it reads that instance.
   - Otherwise it matches the node's private IP to an EC2 instance in the page's profile and region. Because that is a best guess, it asks first: **Confirm the instance** shows `10.0.11.4 → i-0697d3b1e8c42a5f9 (name)` with the profile and region, "This instance was matched by its private IP, not taken from the tunnel. Opening it starts a Session Manager session." Click **Read its logs** or **Cancel**.
   - Several instances with that IP: pick one. None: "No EC2 instance in … has the private IP …, so its logs can't be read from here."
3. Pick a file. ARNscope shows its last 200 lines (it reads the last 64 KB).

Sessions may be recorded by your account, including file contents.

**Search**:

| Option | How it searches |
| --- | --- |
| **This file** | Plain text, case-sensitive (`grep -F` on the instance), in the open file. **Level**: **Any level**, **Warning and above** or **Error and above**. A level alone, with no text, works too. Shows the newest 2,000 matches; the header says how many there were in all. |
| **Search with /greplog** | Backends and compute nodes only, when their HTTP port is reachable (see Live routes). The node searches its own logs: a regular expression, by **Level** (Info, Warning, Error or above, or Fatal) and **Time** (last hour, 6 hours, 24 hours, or all kept logs). At most 2,000 lines. Also works when the node's instance cannot be found. |

Searches take at most 200 characters on one line. Backend and compute node logs mark levels as `E`, `W`, `I` at the start of a line, not `ERROR`, so search by **Level** rather than for the word. Warning and error lines are tinted.

Other controls: **Jump to latest**, **Jump to first match**, **Wrap lines**, **Read the last lines again** and **Open in Files**, which opens the same file in EC2 → Files. There is no follow mode: read the last lines again to see new ones. A log file that is a link pointing outside the log folder is refused.

The Session Manager session opens when you pick a node and closes when you disconnect, pick another cluster or cancel.

## What changes something

| Action | What it changes | How it asks |
| --- | --- | --- |
| **Stop query** | Cancels one running query (`KILL QUERY`). | Native dialog naming the query, user and database; sent once; logged locally. |
| **Add forward(s) and restart** | Adds forwards to the cluster's saved tunnel and restarts it, ending connections on it. | Only on the button; the prompt names each forward and the SSM sessions it uses. |
| Picking a node on **Logs** | Starts a Session Manager session on that instance (logged in CloudTrail). | An IP match asks first. |
| **Connect** through a stopped tunnel | Starts the tunnel's SSM sessions. | Only on **Start tunnel and connect**. |

Everything else reads. The observer user SQL, the grant, the profiling statement and **Open in Query console** never run anything from this page.

## Permissions

| What | AWS actions |
| --- | --- |
| Connect with a Secrets Manager password (also read again for **Stop query** and the live metrics, which use a second connection) | `secretsmanager:GetSecretValue` |
| Pick a secret in the cluster dialog | `secretsmanager:ListSecrets` |
| Connect through an ARNscope tunnel | The tunnel's SSM permissions, see [SSM tunnels](https://arnscope.com/docs/ssm-tunnels#permissions) |
| Logs tab | `ec2:DescribeInstances` (to match the node's IP), `ssm:StartSession`, `ssm:TerminateSession` |

On the StarRocks side, `OPERATE ON SYSTEM` covers the node views, running queries, tablet health and stopping other users' queries. `SELECT` on a database's tables lets the user see that database's loads, partitions and task runs. The [IAM permission check](https://arnscope.com/docs/iam-permission-check) shows which AWS actions your role has.

## Limitations

- StarRocks has no IAM login. Use a Secrets Manager secret (recommended) or a typed password.
- One frontend per cluster connection. The page does not fail over to another frontend.
- Restricted users see only the loads, tables and task runs they have privileges on, so counts can be lower than the cluster's real totals.
- Load history goes back only as far as StarRocks keeps it, and the Loads table shows at most 500 loads per read.
- Results are cut at 1,000 rows or 1 MiB per statement; the Storage tab lists the 500 largest tables and 1,000 partitions per table.
- No auto-refresh outside the live metrics, and no alerts.
- Live charts need an ARNscope tunnel or a direct connection; a local port route gets no charts. At most 32 nodes are charted, and charts keep about one hour.
- The Logs tab reads only `/var/log/starrocks/{fe,be,cn}` on EC2 instances it can find in the page's profile and region, and has no follow mode.
- `information_schema.loads` needs StarRocks 3.1 or later, and the Storage tab needs 3.x.

Need something else? Write to [hello@arnscope.com](mailto:hello@arnscope.com) and tell us what you use.

Source: https://arnscope.com/docs/starrocks
