AZ-400 domain - 8% of the exam

Implement an Instrumentation Strategy

Implement an Instrumentation Strategy is 8% of the AZ-400 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

25
Practice questions
2
Objectives
13
Medium
12
Hard

Where people go wrong

  • Swapping Application, Container and VM Insights

    The wrong answers hand a workload to the wrong Insights feature. VM Insights, Container Insights and Application Insights each look plausible for any compute, so one is offered where another belongs. Application Insights collects request, dependency and exception telemetry with correlated traces. Container Insights reports node, pod and container resource metrics for AKS. VM Insights collects guest performance counters and a dependency map for virtual machines. The layer being monitored, application, cluster or machine, decides which one applies.

    See it in a sample question
  • Choosing an alert type that cannot see the condition

    The wrong answers pick an Azure Monitor alert type that cannot evaluate the stated condition. An activity log alert reacts to control plane operations, not application telemetry. A metric alert needs a pre-aggregated metric and a threshold, so it cannot filter on a specific downstream error code. A log search alert runs a scheduled Kusto query and fits a custom count. Smart Detection learns a baseline, so it suits abnormal degradation with no fixed threshold, but not an explicit count rule.

    See it in a sample question
  • Using the wrong Kusto operator

    Each wrong option names a real Kusto Query Language operator that answers a different question. Union stacks rows without matching a key, where join pairs requests with exceptions on operation_Id. Join combines rows within reachable tables, where the app expression inside a union reaches other Application Insights resources. Summarize with bin omits empty intervals, where make-series fills them. Grouping by operation name gives a category table with no time axis, where bin on timestamp gives a trend.

    See it in a sample question
  • Correlating on a property at the wrong scope

    The wrong answers pick a telemetry property whose scope is wrong for the question. A session identifier spans many transactions, a role instance or cloud_RoleName says where a record ran, and a client address can be shared by many users. None of them isolates one transaction. operation_Id is the same on every request, dependency and exception in one end-to-end transaction, while operation_ParentId points to the span that directly invoked a call. Whole-chain questions use the first, direct-caller questions the second.

    See it in a sample question
  • Borrowing another tool to report pipeline failures

    The wrong answers borrow a control from a different tool to report workflow failures. Azure Monitor alerts, whether metric or activity log, cannot see Azure Pipelines or GitHub Actions run outcomes. Branch policies and branch protection status checks gate pull request merges, so they never fire on a production stage failure or a scheduled nightly run. The built-in route is an Azure DevOps notification subscription for the run failed event, or GitHub's own Actions notifications to watchers.

    See it in a sample question

Objectives in this domain

What to study

The official documents this domain's practice questions cite most.

Sample questions from this domain

Free sampleImplement an Instrumentation Strategymedium

A team running a fleet of Azure virtual machines wants guest operating system performance counters together with an automatically discovered map of the network connections and process dependencies between those machines, so they can see which servers talk to each other. Which Azure Monitor feature delivers both the counters and the dependency map?

  • A"VM Insights", because it collects guest operating system performance counters from each machine and automatically discovers a map of the network connections and process dependencies between the servers. Correct
  • B"Application Insights", because instrumenting the applications on each virtual machine collects request and dependency telemetry that can be assembled into a map of how the servers communicate with one another.
  • C"Container Insights", because enabling it on the virtual machines gathers resource usage for the workloads and draws a topology of the connections that the hosted containers make between the servers.
  • DA metric alert rule on the virtual machine resource, because configuring processor and memory thresholds collects the guest counters and the alert evaluation builds a dependency map of the affected machines.
Select VM Insights to collect guest performance counters and an automatic network and process dependency map across virtual machines. VM Insights is the Azure Monitor solution for virtual machines. It collects guest operating system performance counters and uses a dependency agent to discover the processes running on each machine and the network connections between them, rendering a topology map. Application Insights maps application dependencies rather than hosts, Container Insights targets containers, and a metric alert rule only evaluates existing metrics, so none of those supply both the guest counters and the host dependency map.

Why A is correct: VM Insights is purpose-built for virtual machines, collecting guest performance counters and using its dependency agent to discover and draw the connection and process map between hosts.

Why B is wrong: Application Insights maps application-level request and dependency calls, which sounds related, but it requires application instrumentation and does not provide guest operating system performance counters or a host network dependency map.

Why C is wrong: Container Insights targets container and Kubernetes workloads, so it is a poor fit for plain virtual machines and does not produce guest counters or a host-to-host connection map.

Why D is wrong: A metric alert rule evaluates platform metrics and fires notifications, which is tempting for monitoring, but it neither collects guest counters nor produces any dependency map between machines.

Free sampleImplement an Instrumentation Strategymedium

A team wants to be paged when the server-side failure rate of their Application Insights instrumented web app rises above a threshold for several consecutive minutes, and they want the same rule to send an email and trigger a webhook without duplicating recipient configuration. In Azure Monitor, which combination should they configure?

  • AAn activity log alert on the subscription's administrative events, paired with an action group that holds the email recipients and the webhook so the notification targets are reused across the team's rules.
  • BA metric alert rule on the failure metric whose condition is evaluated over the chosen window, paired with an action group that holds the email recipients and the webhook so the notification targets are reused. Correct
  • CA metric alert rule on the failure metric whose condition is evaluated over the chosen window, with the email recipients and the webhook configured individually inside the alert rule itself rather than in any shared object.
  • DA scheduled log search alert that queries raw request logs on a recurring timer, with the email recipients and the webhook configured individually inside the query alert rule itself rather than a shared object.
Pair a metric alert rule with a reusable action group to alert on an Application Insights failure metric and centralise notification targets. A metric alert rule continuously evaluates a metric such as failed request rate against a threshold over an aggregation window and fires when the condition holds. An action group is a separate reusable object that defines the actions to take, including email and webhook, so multiple rules can share one set of recipients. Embedding recipients in each rule or using an activity log or scheduled log search alert either duplicates configuration or watches the wrong signal.

Why A is wrong: An activity log alert reacts to control plane operations such as resource changes, which is tempting, but it cannot watch an application failure-rate metric, so it never fires on the condition described.

Why B is correct: A metric alert evaluates the failure metric against a threshold over a window, and an action group centralises the email and webhook actions so the same recipients are reused across rules, exactly meeting the need.

Why C is wrong: The metric alert rule is correct, but embedding recipients in each rule forces duplicated configuration and defeats the requirement to avoid repeating the notification targets across rules.

Why D is wrong: A log search alert can compute a failure rate, but running it on a timer adds latency and cost over a metric alert, and embedding recipients per rule still duplicates the notification configuration.

Free sampleImplement an Instrumentation Strategyhard

An analyst wants, for each failed request in the last hour, the exception details emitted while that same request was handled, so failures can be paired with their root-cause exceptions. The requests and exceptions are in separate tables but share the operation identifier. Which Kusto Query Language operator stitches matching rows from the two tables together by that identifier?

requests
| where success == false and timestamp > ago(1h)
| <operator> (exceptions) on operation_Id
  • AUse the union operator, because it merges the rows of the requests and exceptions tables into one result set keyed on the shared operation identifier so matching failures and exceptions appear together.
  • BUse the join operator, because it matches rows from the requests table to rows in the exceptions table that share the same operation identifier, returning each failure beside its corresponding exception. Correct
  • CUse the mv-expand operator, because it expands the exceptions associated with each failed request into individual rows, aligning every failure with the exception data through the operation identifier.
  • DUse the lookup operator, because it appends columns from the exceptions table to the requests table on the operation identifier, behaving like a join but supporting many exceptions per request.
Use the Kusto join operator to correlate rows across the requests and exceptions tables on a shared operation identifier. The join operator combines two tables by matching rows that share a key, so joining requests to exceptions on operation_Id returns every failed request next to the exception emitted within the same operation. The union operator only stacks rows without matching, mv-expand works within one table, and lookup assumes unique keys, so none performs the keyed correlation that join does.

Why A is wrong: The union operator stacks rows from both tables without matching on a key, so it cannot pair each failed request with its exception and ignores the on clause entirely.

Why B is correct: The join operator correlates rows across two tables on a shared key, so joining requests to exceptions on operation_Id returns each failed request paired with the exception raised in the same operation.

Why C is wrong: The mv-expand operator unpacks a multi-value column within a single table and does not combine two separate tables, so it cannot bring exception rows alongside request rows.

Why D is wrong: The lookup operator enriches rows from a dimension table that has unique keys, so when several exceptions share one operation identifier it does not return every matching exception as a full join does.

Free sampleImplement an Instrumentation Strategyhard

A request entering a web front end fans out to three downstream microservices, each sending telemetry to the same "Application Insights" workspace. An engineer needs to retrieve every request, dependency, and exception that belongs to one specific user transaction so the full call chain can be reconstructed. Which telemetry property should the engineer filter on to gather that complete chain?

  • AFilter on session_Id, because the session identifier ties together all telemetry produced during one user's browsing session, which includes the request and its downstream calls.
  • BFilter on cloud_RoleInstance, because that property names the specific server instance handling the work and therefore links the request to the dependencies it triggered downstream.
  • CFilter on operation_Id, because Application Insights assigns the same operation identifier to every request, dependency, and exception emitted while handling one end-to-end transaction across the services. Correct
  • DFilter on client_IP, because the originating client address is constant for a user, letting the engineer pull together every request and dependency raised on that user's behalf.
Correlate distributed-trace telemetry across microservices by filtering on the shared operation_Id that Application Insights propagates through a transaction. Application Insights implements distributed tracing by propagating a correlation context so that every request, dependency, and exception within one end-to-end transaction carries the same operation_Id. Filtering telemetry on that identifier reconstructs the full call chain, whereas session, role-instance, or client-address fields group records by criteria unrelated to a single transaction.

Why A is wrong: A session identifier groups a user's activity over time, often spanning many transactions, so it is too broad to isolate the single call chain the engineer wants to reconstruct.

Why B is wrong: The role instance identifies which machine emitted a record, not which transaction it belongs to, so filtering on it mixes unrelated requests served by the same instance.

Why C is correct: The operation_Id is propagated through the call chain and stamped on all correlated telemetry, so filtering on it returns exactly the spans belonging to a single end-to-end transaction.

Why D is wrong: A client address can be shared by many users behind a gateway and stays the same across separate transactions, so it cannot precisely scope one end-to-end call chain.

Free sampleImplement an Instrumentation Strategymedium

A team running multistage YAML pipelines in Azure Pipelines wants the platform to notify a shared distribution list whenever any deployment run to the production stage fails, using built-in subscription management rather than scripting their own notifier. Which approach best meets this with the least custom code?

  • AAdd a final pipeline stage that runs only on failure and uses a script task to call an email API directly, sending the failure message to the distribution list whenever the production deployment does not succeed.
  • BCreate an Azure Monitor metric alert on the pipeline resource for the failed run count, attached to an action group that emails the distribution list whenever the production deployment run reports a failure.
  • CConfigure a project-level notification subscription in "Azure DevOps" for the run failed event, scoped to the relevant pipeline, so the platform emails the distribution list automatically when a run fails. Correct
  • DSet required branch policies on the production branch so a failed deployment blocks the merge, relying on the policy violation message to inform the distribution list that the production run did not succeed.
Use built-in Azure DevOps notification subscriptions to alert on pipeline run failures without writing custom notification code. Azure DevOps provides notification subscriptions that trigger on pipeline events, including run failed, and deliver email to chosen recipients or teams. Scoping a subscription to a pipeline gives automatic failure notifications with no custom code. A failure-only script stage rebuilds that plumbing by hand, Azure Monitor does not expose pipeline run outcomes as a pipeline-resource metric, and branch policies act on merges rather than deployments.

Why A is wrong: A failure-only script stage works but reintroduces custom notification code and credential handling, which conflicts with the requirement to rely on built-in subscription management.

Why B is wrong: Azure Monitor metric alerts watch resource metrics and is tempting for any alerting, but Azure Pipelines run outcomes are not exposed as a pipeline-resource metric there, so the rule has nothing to evaluate.

Why C is correct: Built-in notification subscriptions in Azure DevOps fire on pipeline events such as run failed and deliver to the chosen recipients without any custom code, matching the stated requirement.

Why D is wrong: Branch policies gate pull request merges and never run at deployment time, so they cannot detect a production stage failure or notify anyone about a failed run.

Other domains in this exam

See also the AZ-400 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by Microsoft. Original, blueprint-aligned practice material only.