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 querythat limits every table to a recent window, such as--timespan PT1Hfor the last hour, on top of any filter in the query. Lesson 31.1 - @file (--analytics-query @)
- Writing
@pathas 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:
-wthe workspace customerId,--analytics-querythe query text (single-quoted in bash),-o tableto 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:typemeans "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 -wwants 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 / totalwith two whole numbers gives 0 for any rate under 100%. Writeerrors * 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 Computerwhen both sides call it that;on $left.Computer == $right.Nodewhen 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 eventsshows): 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);
ascfor the other way. Lesson 31.3 - parse (KQL) (parse with, | parse)
- Cuts fields out of text by a pattern of fixed literals and
name:typecaptures: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
- print (KQL)
- 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
- 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
bycolumns and computes aggregates once per group:| summarize errors = countif(Success == false) by AppRoleName. Likesort | uniq -cin 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.
letcan 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/refundhas 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