SentinelOne Cheat Sheet
SentinelOne Deep Visibility and PowerQuery syntax. Every field name traces to a published source.
SentinelOne's full documentation sits behind a customer login. Everything here comes from SentinelOne's own public engineering and threat research posts that ship complete queries, and each section links to its source.
Before you read the table
- The field list is not the schema. The console's autocomplete is the authority on the rest.
- Only event.type values that appear in a published query are named. The full list is not public.
61 rows.
| Syntax | Meaning |
|---|---|
| filter | command | command | A PowerQuery starts with a plain Deep Visibility filter expression (no leading pipe) and then chains commands with the pipe character. Everything before the first pipe selects events; everything after it transforms them. |
| dataSource.name = 'SentinelOne' | Scopes a query to SentinelOne agent telemetry rather than any other source feeding the Data Lake. Every SentinelOne-published hunting query opens with it. |
| filter → group → let → columns → filter | The shape SentinelOne's own published queries follow: select events, aggregate them, compute derived fields from the aggregates, choose the output columns, then filter on what you just computed. A second `filter` after the aggregation is how you threshold a summary. |
| | filter <condition> | Discards records that do not match a condition. Placed after a `group` or `columns` stage, it filters on the fields that stage produced rather than on raw event fields. |
| | limit N | Caps the number of records displayed or processed by subsequent commands. Worth setting explicitly on a wide hunt so an aggregation downstream stays bounded. |
| | sort -field | Determines the order records are displayed in. A leading `-` sorts descending. |
| | transpose | Removes columns from a table and creates a new column from their values: for turning a wide summary into a narrow one. |
| = | Equality against a literal. String literals are single-quoted (double quotes appear in SentinelOne's own queries too). |
| and / or | Logical conjunction and disjunction. Parenthesise groups when you mix them: SentinelOne's own published queries do. |
| !( ... ) | Negates a whole parenthesised expression: the way to exclude a known-good hash set from an otherwise broad file hunt. |
| contains | Substring match. The most-used operator in SentinelOne's published hunting queries, because command lines and paths are rarely exact-matchable. |
| contains:anycase | Case-insensitive substring match. Accepts a parenthesised list, in which case any element matching is enough. |
| contains (a, b, c) | Substring match against several candidates at once: one clause instead of a chain of ORs. |
| in ( ... ) | Exact membership against a list of literals. This is the shape SentinelOne publishes IOC hash sweeps in. |
| in:anycase ( ... ) | Case-insensitive membership test: the right operator for Windows process names, whose casing is not consistent in telemetry. |
| matches "regex" | Regular-expression match against a field. Used inside a filter, and equally inside a ternary to bucket values. |
| > < >= <= | Numeric comparison. Works on raw event fields and on values you computed in an earlier `group` or `let` stage. |
| && | The C-style logical AND, used inside a `filter` expression alongside comparisons. |
| event.type | The event class. SentinelOne's published queries use 'Process Creation' and 'IP Connect'; the console's autocomplete lists the rest, and this sheet does not guess at values that have not been published. |
| event.time | The event timestamp. Bucket it with `timebucket()` in a `let` before grouping, to turn a raw event stream into a timeline. |
| event.network.direction | Direction of a network event. 'OUTGOING' is the value SentinelOne uses in its own egress-hunting example. |
| endpoint.name | The agent hostname. The natural `by` key for almost every summary, and the field you pivot on once a hunt returns a hit. |
| endpoint.os | The endpoint operating system: 'windows' in SentinelOne's published Windows-specific hunts. |
| dataSource.name | Which product fed the record into the Data Lake. Pin it to SentinelOne when you want agent telemetry rather than an ingested third-party log. |
| task.name | Scheduled-task name. A persistence-hunting field: SentinelOne uses it alongside process and file predicates in the same query. |
| src.process.name | The SOURCE (acting/parent-side) process image name. In SentinelOne telemetry `src.*` is the process that did something and `tgt.*` is what it did it to: getting the two the wrong way round is the most common mistake in an S1 query. |
| src.process.cmdline | Command line of the source process. The highest-signal field on the platform for anything script- or LOLBin-shaped. |
| src.process.parent.name | The grandparent in the chain: the process that spawned the source process. This is what turns a single event into a lineage. |
| src.process.parent.cmdline | Command line of that grandparent process. Aggregate it with `array_agg_distinct()` to see every way a parent was invoked. |
| src.process.parent.publisher | Signing publisher of the parent process image: the quick signed/unsigned sanity check on a suspicious chain. |
| src.process.user | The user context the source process ran as. Pair it with the process name to separate service activity from a real interactive user. |
| src.process.storyline.id | The Storyline identifier: SentinelOne's correlation key that ties every related process, file, thread and network event together. Copy it out of a hit and query on it to get the whole incident in one shot. |
| tgt.process.name | The TARGET process image name: on a Process Creation event, the process that was created. |
| tgt.process.cmdline | Command line of the target process. The field to aggregate when you want every distinct way a binary was invoked across the estate. |
| tgt.process.displayName | The binary's file description string: "Lists the current running tasks" for tasklist.exe. Catches a renamed LOLBin that a name-based filter would miss. |
| tgt.process.publisher | Signing publisher of the target process image. |
| tgt.file.path | Full path of the file the event acted on. Remember to cover both path separators when a hunt spans Windows and Unix endpoints. |
| tgt.file.sha1 | SHA-1 of the target file. The field SentinelOne publishes its own IOC sweeps against, using `in ( ... )`. |
| tgt.file.size | Size of the target file in bytes. A size floor is a cheap way to cut a broad filename hunt down to plausible payloads. |
| src.ip.address / dst.ip.address | Source and destination IP of a network event. Group by the destination to map where a host has been reaching out to. |
| src.port.number / dst.port.number | Source and destination port. A specific port pair is often the cheapest first filter for an agent or C2 you already know the shape of. |
| | group name = func() by field | Aggregates records, grouping by one or more fields and computing statistics for each group. Comma-separate several aggregates, and several `by` keys. |
| count() | Counts records in the group. |
| count(<condition>) | Conditional count: counts only the records satisfying a predicate, so you can put a total and a subset side by side in one pass. |
| estimate_distinct(field) | Approximate distinct count over the group. The cardinality signal you threshold on when hunting for spray or enumeration behavior. |
| sum() / min() / max() | The standard numeric aggregates over a group. SentinelOne documents `percentile()` alongside them; no published example of its argument form was available, so none is invented here. |
| array_agg_distinct(field) | Collapses every DISTINCT value in the group into one array cell. This is what turns "1,400 process events on this host" into one readable row listing what actually ran. |
| timebucket(field, "interval") | Rounds a timestamp down to an interval. Assign it back over `event.time` in a `let`, then group by it, and you have a per-interval timeline. |
| array_to_string(array, sep) | Renders an aggregated array back into a single readable string with a separator. The step that makes an `array_agg_distinct()` column legible in an exported report. |
| by field = <expression> | The `by` key can be a computed expression, including a constant. A static key (`by key = 1`) collapses everything into one group: the trick SentinelOne publishes for computing a percentage-of-total. |
| | columns a, b, c | Chooses which columns appear in the output table, in the order given. |
| | columns name = <expression> | Defines a new column inline while selecting, including a ternary, which is how you bucket a numeric value into a label. |
| | let name = <expression> | Defines one or more new fields on the table. Later stages (`columns`, `filter`, `sort`) can then refer to them by name. |
| + - * / % | Arithmetic operators, plus negation. Available anywhere an expression is: in `let`, in `columns`, and inside a `filter`. |
| (cond) ? a : b | Ternary conditional. Chain them for multi-way classification: SentinelOne's own example nests one inside the false branch of another. |
| format("%s %s", a, b) | printf-style string formatting: the way to build one composite field out of several columns before grouping on it. |
| | parse "regex" from field | Extracts new columns inline using a regular expression with named captures, reading from the named field. The captured names become fields the next stage can group on. |
| | join a = (...), b = (...) on key | Runs two or more named subqueries and merges them side by side on a shared key, keeping only records that match. Each subquery is a full query in its own right, pipes included. |
| alias.field | After a join, reference a column from a specific side by its subquery alias. This is how you compute an elapsed time between two event types. |
| | union (...), (...) | Runs two or more subqueries and stacks their results as ROWS rather than columns: the way to append a synthetic "all hosts" total row underneath a per-host breakdown. |
| join ... by key = "1" | Joining on a statically-assigned constant key pairs every row against a single aggregate row: the documented SentinelOne pattern for percentage-of-total and rate calculations. |