OnCallReadyStart learning

Azure III: Monitor, KQL & Cost: glossary

128 terms, in plain words, with where each one is taught.

_BilledSize
A column on every Log Analytics record: its billed size in bytes. Sum it by container or namespace to find who is filling the bill. Lesson 31.26
--timespan
An option of az monitor log-analytics query that limits every table to a recent window, such as --timespan PT1H for the last hour, on top of any filter in the query. Lesson 31.1
@file (--analytics-query @)
Writing @path as the value of any az argument makes az read the value from that file, e.g. --analytics-query @hb.kql. Lesson 31.1
=~ (!~, in~)
KQL "equals, ignoring case". == is exact and case-sensitive. Lesson 31.3
action group
A saved list in Azure Monitor of who to notify and how (email, SMS, phone call, webhook) when an alert fires. Lesson 31.14
Activity log (AzureActivity)
Azure's record of every control-plane change: who did what to which resource, kept 90 days. Exported to a workspace it is the AzureActivity table. Columns: Caller (who), OperationNameValue (what), _ResourceId (which resource). Lesson 31.1
aggregate (aggregation function, aggregates)
A function that turns many rows into one value, such as count(), avg() or max(). Used inside summarize. Lesson 31.5
ago() (ago, now())
KQL function: ago(5m) is the time five minutes before now. now() is the current time. Lesson 31.3
Analytics plan (Basic plan, Basic logs, Auxiliary plan)
The table plans of Log Analytics. Analytics: full KQL, normal price. Basic: much cheaper ingestion, limited KQL, short retention, for noisy tables. Auxiliary: cheapest, for rarely-queried data, custom tables only. az monitor log-analytics workspace table update -g rg-oncall-lab --workspace-name law-sysop -n ContainerLogV2 --plan Basic. Lesson 31.26
Application Insights (App Insights)
The part of Azure Monitor that records what an application itself does: one row per request served, per outgoing call, per exception, per log call. The app sends them through a library in its code. Lesson 31.1
AppRequests (AppDependencies, AppExceptions, AppTraces)
The Application Insights table with one row per HTTP request an app served: TimeGenerated, AppRoleName (service), Name (method and path), ResultCode, Success, DurationMs. Its siblings: AppDependencies (calls the app made), AppExceptions (errors thrown), AppTraces (the app's log calls). Lesson 31.1
AppRoleInstance
The AppRequests column that says which instance (pod) served a request. AppRoleName says which service. Lesson 31.5
arg_max (arg_max(), arg_min)
arg_max(A, B, C): the row where A is largest, with B and C from that row. arg_max(TimeGenerated, *) per pod gives each pod's latest, current state. Lesson 31.5
AuditEvent
The diagnostic log category of Key Vault that records every call to the vault: who asked for which secret and what the answer was. Lesson 31.1
az consumption usage list (consumption API, pretaxCost, consumedService)
The az command that lists the subscription's usage, one row per resource per day, with consumedService, instanceName and pretaxCost. pretaxCost is a string, so sum it with awk. Lesson 31.26
az extension (extension (az), az costmanagement)
An optional add-on for the az CLI that adds commands, installed separately (az extension add -n <name>). Lesson 31.26
az monitor log-analytics query
The az command that runs one KQL query: -w the workspace customerId, --analytics-query the query text (single-quoted in bash), -o table to print a table. Lesson 31.1
Azure Advisor (Advisor)
Azure's built-in service that lists recommendations for your resources: things to fix, secure or save money on.
Azure Monitor
Azure's name for all of its monitoring features together: metrics, logs in Log Analytics workspaces, the Activity log, and the alerts built on them. Lesson 31.1
Azure Monitor Agent (AMA)
The small program that runs on each node (or VM) and uploads its logs and numbers to Azure Monitor. Lesson 31.1
AzureDiagnostics
The old shared Log Analytics table that many Azure services write their diagnostic logs into. Column names carry a type suffix: _s string, _d number, _g GUID, _b true/false. Lesson 31.1
between (KQL)
KQL range test, inclusive at both ends: DurationMs between (1000 .. 5000), or a time window with two datetimes. Lesson 31.3
bin() (bin)
Rounds a value down to a bucket: bin(TimeGenerated, 5m) turns every timestamp into the start of its 5-minute slot, so grouping by it gives one row per slot. Lesson 31.5
budget (az consumption budget, budget alert)
An Azure object that tracks spending against an amount you set for a period and emails people at thresholds (50/80/100%) as spending approaches it. az consumption budget create --budget-name oncall-lab-monthly --amount 1500 --time-grain Monthly --start-date 2026-09-01 --end-date 2027-08-31 --category Cost. Lesson 31.26
capture (parse) (typed capture, name:type)
In a parse pattern, name:type means "the text up to the next literal goes into a new column called name, as type" (int, long, real, or string if no type). Lesson 31.11
commitment (baseline, steady baseline)
Paying for a period whether you use it or not, in exchange for a discount. Commit only to the capacity you are sure to use all year, never to the peak. Lesson 31.26
commitment tier
A Log Analytics pricing option: promise at least 100 GB a day (or more) and pay a lower price per GB. Lesson 31.26
Container Insights
The AKS monitoring add-on. An agent on every node uploads container logs, pod and node snapshots, Kubernetes events and CPU/memory numbers into a workspace. Lesson 31.1
ContainerLogV2
The Log Analytics table with every line containers wrote to stdout and stderr, with PodName, PodNamespace, ContainerName, LogLevel and LogMessage. Lesson 31.1
contains (KQL) (!contains, contains_cs)
KQL string test that matches any substring, ignoring case. It scans every row, so it is slow; use has unless you need part of a word. Lesson 31.3
Cost Management (Azure Cost Management, cost analysis)
Azure's service for viewing and analysing what you spend, by service, resource, tag or team. Lesson 31.26
count (KQL) (| count)
The KQL operator that returns one row with the number of rows it was given. Lesson 31.3
countif() (countif, count())
count() counts the rows of a group; countif(condition) counts only the rows where the condition is true. Lesson 31.5
cumulative counter (cumulative, PodRestartCount)
A number that only ever grows, a running total - like PodRestartCount. To know how much happened in a window, take max minus min, never the sum. Lesson 31.1
customerId (workspace ID, workspace GUID)
The GUID that identifies a Log Analytics workspace to the query API. az monitor log-analytics query -w wants this, not the workspace name or its resource ID. W=$(az monitor log-analytics workspace show -g rg-oncall-lab -n law-sysop --query customerId -o tsv). Lesson 31.1
daily cap
A limit of GB per day after which a workspace stops accepting data. Fine for dev; in production it throws away logs during exactly the incident that produced them. Lesson 31.26
data collection rule (DCR, data collection rules)
The Azure resource that tells the monitoring agent what to collect and where to send it. Container Insights' DCR can exclude namespaces and log levels. Lesson 31.26
datetime (datetime())
KQL's type for a point in time, written datetime(2026-09-24T09:15:00Z) (Z = UTC). Lesson 31.3
dcount() (dcount)
Distinct count: how many different values a column has in a group. An estimate, exact for small numbers. Lesson 31.5
dead man's switch (dead mans switch, heartbeat alert)
An alert that fires when an expected signal stops arriving ("no Heartbeat from X in 10 minutes"), catching failures that leave nothing behind to report an error.
diagnostic setting (diagnostic settings, az monitor diagnostic-settings)
A setting on an Azure resource that sends the resource's own logs (Key Vault audit, App Gateway access logs, AKS control plane logs) to a workspace. Nothing is sent until you create one. az monitor diagnostic-settings create -n kv-audit --resource <id> --workspace <id> --logs '[{"category":"AuditEvent","enabled":true}]'. Lesson 31.1
dimension table
A small table of facts about things (each node's pool, each app's owner) used to enrich a big table of events. Lesson 31.9
distinct (KQL) (| distinct)
The KQL operator that returns each unique combination of the named columns once: | distinct AppRoleName. Lesson 31.3
dynamic (KQL) (dynamic())
KQL's type for a JSON value (object, array or plain value). Walk into it with dots and brackets: LogMessage.level, Labels[0].agentpool. Lesson 31.11
enrichment
Adding columns from a small "facts about each thing" table (node to pool, pod to team) onto a big table of events, usually with a leftouter join. Lesson 31.9
extend (| extend)
The KQL operator that adds a computed column and keeps the others: | extend seconds = DurationMs / 1000.0. Lesson 31.3
extract() (extract)
extract(regex, N, text) runs a regular expression and returns the part inside the Nth pair of parentheses as a string, or empty. Lesson 31.11
first bad minute
The earliest 1-minute bucket in which errors appear: the incident start for the timeline, in UTC. Lesson 31.14
forecast alert
A budget alert that fires when Azure predicts you will cross the amount by the end of the period, before you actually do. Lesson 31.26
getschema
A KQL operator that lists a table's columns and their types: KubePodInventory | getschema. Run it before writing a query against a new table. Lesson 31.3
has (!has, has_any, has_cs)
KQL string test that matches a whole term (word), ignoring case, using the workspace's index - fast. "upstream connect" has "upstream" but not "stream". Lesson 31.3
Heartbeat
A Log Analytics table where every agent writes one "I am alive" row per minute. A node whose heartbeats stop has gone away. Lesson 31.1
HyperLogLog
The algorithm KQL uses to estimate distinct counts (dcount) cheaply; within a couple of percent on large numbers. Lesson 31.5
identity_claim_oid_g (CallerIPAddress, ResultSignature, id_s)
Key Vault audit columns in AzureDiagnostics: the caller's object ID (identity_claim_oid_g), where the call came from (CallerIPAddress), the answer (ResultSignature, e.g. OK or Forbidden), which secret (id_s).
incident playbook (playbook)
A fixed list of questions and ready queries for an incident: what is broken, since when, what disappeared, what else happened, what changed, who is affected. Lesson 31.14
ingestion (ingested, GB ingested)
Data arriving in a workspace. Log Analytics bills per gigabyte ingested. Lesson 31.1
ingestion latency (_TimeReceived)
The delay between something happening and its record being queryable, usually 1-3 minutes. The last minutes of any query are incomplete. Lesson 31.1
ingestion-time transformation (transformation)
A KQL filter Azure applies to data as it arrives in a workspace, to drop or trim rows before you pay to store them. Lesson 31.26
innerunique
KQL's default join kind: it first keeps one arbitrary left row per key, then inner-joins. It silently drops rows, so always write the kind. Lesson 31.9
integer division trap (integer division)
errors / total with two whole numbers gives 0 for any rate under 100%. Write errors * 100.0 / total. An alert written the wrong way never fires. Lesson 31.5
isnotempty (isempty, isnotnull, isnull)
KQL functions that test whether a column has a value. A missing value is called null. Lesson 31.3
ISO 8601 duration (PT1H, PT30M, P1D)
A standard way to write a length of time: P = period, T = the time part follows. PT1H is one hour, PT30M thirty minutes, P1D one day. Lesson 31.1
join (KQL) (join, | join)
Puts two tables side by side: each row of the left table is matched with the rows of the right table that have the same key, and glued into one wider row. Lesson 31.9
join key ($left, $right)
The column(s) two tables are matched on. on Computer when both sides call it that; on $left.Computer == $right.Node when the names differ. Lesson 31.9
join kind (kind=inner, kind=leftouter, leftouter)
What a join does with matching and non-matching rows: inner keeps matching pairs, leftouter keeps every left row (right columns empty when unmatched), leftsemi keeps left rows that match. Lesson 31.9
KQL (Kusto, Kusto Query Language)
Kusto Query Language: the language you use to query Log Analytics. A table, then operators separated by |, each taking a table in and handing a table on. Lesson 31.1
KubeEvents
The Log Analytics table of Kubernetes events (what kubectl get events shows): Reason such as BackOff, FailedMount or FailedScheduling, plus the message and the object. Lesson 31.1
KubeEventType
The KubeEvents column that says whether an event is Normal or Warning. Lesson 31.14
KubeNodeInventory
A Log Analytics table with a snapshot of every node every minute: its Ready/NotReady status, labels (as JSON) and kubelet version. Lesson 31.1
KubePodInventory
A Log Analytics table with a snapshot of every pod every minute: namespace, name, status, node (Computer), restart count, last container status. A pod that ran all hour has sixty rows. Use arg_max for its current state and max - min for restarts. Lesson 31.1
last seen
The newest timestamp of each thing (max(TimeGenerated) by Computer). Things that fail by disappearing show up only in last-seen queries. Lesson 31.14
LAW (law-sysop, law-drill)
Short for Log Analytics workspace, used in names like law-sysop. Lesson 31.1
leftanti (kind=leftanti, anti-join)
A join kind that keeps the left rows with no match on the right - "what disappeared": pods whose node stopped reporting, identities with no role. Lesson 31.9
let (KQL) (let)
Gives a value or a sub-query a name for the rest of a KQL query: let app = "cart";. Each statement ends with ;, the last one is the query. Lesson 31.3
Log Analytics Reader
The built-in Azure role that lets you run queries on a workspace (the action Microsoft.OperationalInsights/workspaces/query/*). Lesson 31.1
log search alert (log alert, alert rule, log search alert rule)
An Azure alert rule made of a KQL query, a threshold and a schedule. Azure runs the query every few minutes and notifies people when the threshold is crossed, usually "the query returned rows". Lesson 31.14
long (KQL) (int (KQL))
KQL's whole-number type. count() returns a long, and long divided by long throws away the fraction. Lesson 31.5
lookback (lookback window)
How far back each run of an alert query looks, such as the last 5 minutes. Make it longer than the ingestion delay.
lookup (KQL)
A KQL join specialised for enriching from a small table, leftouter by default. Not simulated in the lab. Lesson 31.9
make_set() (make_set, make_list)
KQL aggregates that collect a group's values into one list: make_set keeps each value once, make_list keeps all of them. Lesson 31.5
monitoring
Collecting logs and metrics from everything you run, so you can see what it is doing and find out why it broke. Lesson 31.1
mv-expand
Multi-value expand: turns an array in one row into one row per element. Lesson 31.11
nanocores (cpuUsageNanoCores)
CPU usage counted in billionths of one core: 1e9 nanocores = 1 core in use.
operator (KQL) (KQL operator, tabular operator)
One step of a KQL query after a |, such as where or summarize. It takes a table in and hands a table on. Lesson 31.3
order by (sort by)
The KQL operator that sorts rows, newest or biggest first by default (desc); asc for the other way. Lesson 31.3
parse (KQL) (parse with, | parse)
Cuts fields out of text by a pattern of fixed literals and name:type captures: parse LogMessage with * "status=" status:int " duration_ms=" ms:long. Lesson 31.11
parse_json() (parse_json, todynamic)
Turns a string column that holds JSON into a dynamic value you can walk into. Wrap what you pull out in tostring() before grouping. Lesson 31.11
percentile() (percentiles(), percentile_DurationMs_95)
KQL aggregate for a percentile: percentile(DurationMs, 95) is the p95. percentiles(col, 50, 95, 99) gives several at once. Lesson 31.5
Perf (InsightsMetrics)
The Log Analytics table of performance numbers: one row per counter per node or container per sample, such as CPU in nanocores or memory in bytes. Lesson 31.1
performance counter (CounterName, CounterValue, ObjectName)
A named measurement in the Perf table (CounterName, e.g. cpuUsageNanoCores) for a kind of object (ObjectName, e.g. K8SNode), with its value in CounterValue.
PerGB2018
The pricing plan (SKU) of a normal Log Analytics workspace: you pay per gigabyte of data sent in. Lesson 31.1
PreemptScheduled (NodeNotReady)
A Kubernetes event reason on AKS: Azure has announced it will evict a spot node in about 30 seconds. NodeNotReady means a node stopped answering; TriggeredScaleUp means the cluster autoscaler is adding nodes. Lesson 31.14
Makes a one-row table from values you type: print x = 1 + 2. Handy for trying functions. Lesson 31.11
project (KQL) (| project, project-away)
The KQL operator that keeps, renames or computes columns: | project TimeGenerated, code = ResultCode. Lesson 31.3
query pack
An Azure resource that holds saved KQL queries shared by a team, so everyone on call runs the same ones. Lesson 31.14
real (KQL) (double, todouble)
KQL's type for numbers with decimals. One real operand (100.0) makes a division keep its fraction. Lesson 31.5
regression (latency regression)
Something that got worse after it used to be fine, such as a p95 that doubled after a release.
render timechart (render)
A KQL instruction to draw the result as a line chart over time. The portal draws it; the CLI just prints the rows. Lesson 31.5
request ID (trace=, trace ID, correlation ID)
A random ID an app writes on every log line that belongs to one request, so you can find all of them later, across services. Lesson 31.11
reserved instance (reservation, reserved instances, RI)
A 1- or 3-year promise to pay for a specific VM size in a specific region, in exchange for a large discount (up to about 70%). No flexibility. Lesson 31.26
resource-context access
Querying a workspace with rights only on a resource (say Reader on one AKS cluster), and seeing only the rows that came from that resource. How teams share one workspace safely. Lesson 31.1
resource-specific table (AKSAudit, AGWAccessLogs)
A Log Analytics table for one service's diagnostic logs, with proper column names (AKSAudit, AGWAccessLogs). Preferred over AzureDiagnostics for new setups. Lesson 31.1
savings plan (savings plans for compute)
A 1- or 3-year promise to spend a fixed amount per hour on compute, applied across VM sizes and regions. Less discount than a reservation, much more flexible. Lesson 31.26
scalar expression
Anything in KQL that gives one value per row: a column name, 1 + 2, ago(1h). Lesson 31.3
SDK (software development kit)
A library you add to your program's code to use a service, such as the Application Insights library that sends request records. Lesson 31.1
SecretGet (OperationName)
The Key Vault audit operation for "give me a secret's value". Each row of the audit log has one OperationName like this.
SemanticError (SEM0100, SyntaxError, SYN0002)
The KQL error for a query that parses but names something that does not exist, usually a misspelled or wrong-case column (SEM0100). SyntaxError / SYN0002 means the parser gave up at the position it names. Lesson 31.3
shard (data shard)
A chunk of stored data. Log Analytics stores data in chunks by time, so a time filter lets it skip whole chunks. Lesson 31.3
snapshot (disk) (disk snapshot, az snapshot)
A point-in-time copy of a managed disk, billed per GB for as long as it exists. Lesson 31.26
snapshot table (inventory table, inventory tables)
A table that records the whole state of each thing every minute (KubePodInventory, KubeNodeInventory), rather than one row per event. A pod that ran an hour has sixty rows. Lesson 31.1
structured logging (JSON logs, structured logs)
Writing each log line as JSON with named fields (level, msg, duration_ms) instead of free text, so queries read fields instead of parsing text. Lesson 31.11
summarize (| summarize, summarize by)
The KQL operator that groups rows by the by columns and computes aggregates once per group: | summarize errors = countif(Success == false) by AppRoleName. Like sort | uniq -c in bash, grown up. Lesson 31.5
t-digest
The algorithm KQL uses to estimate percentiles without sorting every value. Accurate enough for operations. Lesson 31.5
tabular expression
Anything in KQL that produces a table: a table name, or a table followed by operators. let can give one a name. Lesson 31.9
take (limit (KQL), | take)
The KQL operator that returns any N rows, in no particular order. Not "the latest N" - use top for that. Lesson 31.3
term (KQL) (terms)
A word as KQL's index sees it: text is split at every character that is not a letter or a digit. POST /api/payments/refund has the terms POST, api, payments, refund. Lesson 31.3
term index (index (KQL))
A lookup list the workspace keeps of which rows contain which term, like the index at the back of a book. It is why has is fast and contains is not. Lesson 31.3
time range picker (time picker, Set in query)
The portal's drop-down (Last 1 hour, Last 24 hours) that limits every Logs query. It is not part of the query text, so a pasted query can give a different answer elsewhere.
time series
A list of (time, value) pairs for one measurement, such as CPU every minute. What a line chart draws. Lesson 31.1
TimeGenerated
The column every Log Analytics table has: when the record was created, always in UTC. Filter on it first in every query. Lesson 31.1
timespan
KQL's type for a length of time, written 30s, 5m, 2h, 1d, 250ms. A datetime minus a datetime is a timespan. Lesson 31.3
top (KQL) (| top)
The KQL operator that sorts and keeps the first N in one step: | top 5 by DurationMs. Lesson 31.3
tostring() (tostring, toint, toint())
KQL conversion functions: tostring() to text, toint()/tolong() to whole numbers, todouble() to decimals. Lesson 31.11
union (KQL) (union)
Stacks tables one under the other, merging columns by name. union KubeEvents, ContainerLogV2. Lesson 31.9
Usage table (Usage, Quantity, IsBillable)
The Log Analytics table that records how much data each table (DataType) received per hour, in MB (Quantity), and whether it is billed (IsBillable). Lesson 31.26
verbatim string (@"...")
A KQL string written @"..." in which a backslash is just a character. Handy for regular expressions like @"duration_ms=(\d+)". Lesson 31.3
where (KQL) (| where)
The KQL operator that keeps only the rows matching a condition: | where TimeGenerated > ago(1h). Lesson 31.3
workbook (workbooks, Azure Monitor workbook)
A saved page of charts and queries in the Azure portal, built on Log Analytics queries. Lesson 31.5