CCNA Monitor, troubleshoot, and optimize Azure solutions Questions — Page 2 of 2

Multi-Selecthard

Which THREE features of Azure Monitor can help you diagnose a performance issue in an Azure Virtual Machine?

Select 3 answers

A.Log Analytics workspace queries

B.VM Insights

C.Azure Network Watcher

D.Azure Backup reports

E.Diagnostic settings to send performance counters to Log Analytics

AnswersA, B, E

KQL queries can analyze performance data.

Why this answer

Options A, C, and D are correct. VM Insights provides performance charts. Log Analytics queries allow deep analysis.

Diagnostic settings send data to Log Analytics. Option B is wrong because VM backup is unrelated. Option E is wrong because Network Watcher is for network issues, not VM performance.

Practice this question →

Multi-Selectmedium

You are monitoring an ASP.NET Core web API with Application Insights. You want to view the SQL queries being executed, including the command text and duration, in the Application Insights portal. Which actions must you take? (Select all that apply.) (Choose 2.)

Select 2 answers

A.Install the `Microsoft.ApplicationInsights.Profiler.AspNetCore` NuGet package.

B.Install the `Microsoft.ApplicationInsights.DependencyCollector` NuGet package.

C.Set `EnableSqlCommandTextInstrumentation` to `true` in the `DependencyTrackingTelemetryModule` configuration.

D.Enable adaptive sampling to ensure all SQL queries are collected.

AnswersB, C

This package collects dependency telemetry (including SQL). By default, it does not capture SQL command text; it must be enabled via configuration.

Why this answer

Option B is correct because the `Microsoft.ApplicationInsights.DependencyCollector` NuGet package is required to automatically collect dependency telemetry, including SQL Server calls. Without this package, Application Insights will not capture SQL dependency data at all. Option C is correct because even with the dependency collector installed, SQL command text is not collected by default for security reasons; you must explicitly set `EnableSqlCommandTextInstrumentation` to `true` in the `DependencyTrackingTelemetryModule` configuration to view the actual SQL queries and their duration in the portal.

Exam trap

The trap here is that candidates often assume installing the dependency collector alone is sufficient to see SQL command text, but they overlook the explicit configuration flag (`EnableSqlCommandTextInstrumentation`) required to enable that specific data collection.

Practice this question →

MCQmedium

You have an Azure Function app that processes messages from a Service Bus queue. Under high load, some messages are not processed within the expected time. You need to identify whether the function is throttling due to high CPU or due to a downstream dependency. Which Application Insights feature should you use?

A.Live Metrics Stream

B.Application Insights Profiler

C.Search

D.Application Map

AnswerD

Application Map visualizes components and dependencies, showing where delays occur.

Why this answer

Option C is correct because Application Map shows dependencies and their health, helping identify bottlenecks. Option A (Live Metrics) shows real-time data but not dependencies. Option B (Profiler) is for code-level performance.

Option D (Search) is for raw telemetry.

Practice this question →

MCQeasy

You need to monitor the CPU and memory usage of an Azure Virtual Machine (VM) over the last 30 days. Which Azure service should you use?

A.Azure Service Health

B.Azure Advisor

C.Azure Monitor Metrics

D.Azure Log Analytics

AnswerC

Azure Monitor Metrics stores numerical performance data.

Why this answer

Option A is correct because Azure Monitor Metrics collects and stores performance counters like CPU and memory for Azure VMs. Option B is wrong because Azure Log Analytics works with logs, not metrics. Option C is wrong because Azure Service Health monitors Azure service outages, not VM performance.

Option D is wrong because Azure Advisor provides recommendations, not historical metrics.

Practice this question →

MCQmedium

You need to diagnose a slow-performing Azure Function. Application Insights shows that the function's dependency calls to an external API take an unusually long time. Which Application Insights feature should you use to visualize the end-to-end request flow?

A.Metrics Explorer

B.Live Metrics Stream

C.Application Map

D.Smart Detection

AnswerC

Application Map visualizes the call flow between components and highlights performance issues, including slow dependencies.

Why this answer

Application Map is the correct feature because it provides a visual representation of the end-to-end request flow across distributed components, including dependency calls to external APIs. It shows the latency and failure rates for each dependency, allowing you to pinpoint where the slowdown occurs in the overall transaction.

Exam trap

The trap here is that candidates often confuse Live Metrics Stream (real-time monitoring) with Application Map (end-to-end flow visualization), or they think Metrics Explorer can trace individual requests when it only aggregates data over time.

How to eliminate wrong answers

Option A is wrong because Metrics Explorer is used to query and visualize aggregated metrics (e.g., request count, failure rate) over time, not to trace the flow of a single request through dependencies. Option B is wrong because Live Metrics Stream shows real-time telemetry (e.g., incoming requests, CPU usage) but does not provide a historical or dependency-level flow visualization. Option D is wrong because Smart Detection proactively identifies anomalies (e.g., sudden spikes in failures) using machine learning, but it does not offer a manual, interactive map of request paths.

Practice this question →

MCQeasy

Your application running on Azure App Service is experiencing intermittent high latency. You have enabled Application Insights and noticed that the 'Server response time' metric spikes during peak hours. What is the most likely cause of this issue?

A.Auto-scaling is configured too aggressively.

B.The application is using regional failover, causing delays.

C.The App Service plan is under-provisioned and hitting CPU limits.

D.The application is using too much memory.

AnswerC

High CPU usage during peak hours causes increased response times.

Why this answer

Option B is correct because high CPU usage on the App Service plan during peak hours can cause increased response times. Option A is incorrect because low memory usage would not cause high latency. Option C is incorrect because auto-scaling typically reduces latency.

Option D is incorrect because regional failover does not cause intermittent spikes during regular peak hours.

Practice this question →

MCQmedium

An Azure Function processes events from Event Hubs. You need to monitor the number of events that were successfully processed and those that were dropped due to processing errors. Which approach should you use?

A.Custom metrics in Application Insights.

B.Event Hubs metrics.

C.Stream Analytics job.

D.Log Analytics query on function logs.

AnswerA

Correct. You can use the Application Insights SDK to log custom events or metrics for processed and dropped events.

Why this answer

Custom metrics in Application Insights allow you to track business-specific counters like successfully processed events and dropped events directly from your Azure Function code. By using the `TelemetryClient.TrackMetric()` API within the function's event processing logic, you can increment counters for success and failure scenarios, giving you precise, real-time monitoring of processing outcomes. This approach is more granular than built-in metrics because it reflects your application's custom error handling, not just infrastructure-level throughput.

Exam trap

The trap here is that candidates confuse infrastructure-level metrics (Event Hubs metrics) with application-level custom metrics, assuming that monitoring the Event Hubs output automatically reflects function processing success, when in fact the function's own error handling must be instrumented separately.

How to eliminate wrong answers

Option B is wrong because Event Hubs metrics (e.g., incoming messages, outgoing messages, throttled requests) measure the throughput at the Event Hubs namespace level, not the success or failure of downstream processing in the Azure Function. Option C is wrong because Stream Analytics is a real-time analytics service for processing streaming data, not a monitoring tool for tracking custom application-level events like processed vs. dropped counts. Option D is wrong because Log Analytics queries on function logs can retrieve logged events, but they require parsing unstructured log text and lack the real-time, aggregated metric capabilities that custom metrics in Application Insights provide for dashboards and alerts.

Practice this question →

Multi-Selecthard

Which THREE tools can you use to diagnose performance issues in an Azure App Service? (Choose three.)

Select 3 answers

A.Application Insights

B.App Service diagnostics (Diagnose and Solve Problems)

C.Azure Monitor for VMs

D.Azure SQL Analytics

E.Kudu console for logging and debugging

AnswersA, B, E

Provides detailed application performance monitoring.

Why this answer

Option A (Application Insights), Option B (Kudu console), and Option D (App Service diagnostics) are correct. Option C (Azure SQL Analytics) is for SQL, not App Service. Option E (Azure Monitor for VMs) is for virtual machines.

Practice this question →

MCQeasy

You are using Application Insights to monitor a web application. You need to create an alert that triggers when the server response time exceeds 5 seconds for more than 10% of requests in a 5-minute window. Which type of Azure Monitor alert should you create?

A.Metric alert

B.Log alert

C.Activity log alert

D.Application Insights smart detection alert

AnswerB

Log alerts run a Kusto query that can group and count requests, calculate the percentage with duration > 5000 ms of total requests, and trigger when that percentage exceeds 10 over the evaluation period.

Why this answer

A log alert is correct because the condition involves querying Application Insights trace data to calculate the percentage of requests with a server response time exceeding 5 seconds within a 5-minute window. Log alerts run a Kusto query against the `requests` table, allowing aggregation and threshold evaluation (e.g., >10% of requests), which is not possible with simple metric thresholds.

Exam trap

The trap here is that candidates often assume a metric alert can handle percentage-based conditions, but metric alerts only support simple aggregations (e.g., average, count, max) and cannot compute a ratio of requests meeting a custom condition without a log query.

How to eliminate wrong answers

Option A is wrong because a metric alert can only monitor a single metric value (e.g., average server response time) and cannot calculate a percentage of requests exceeding a threshold; it lacks the query capability to count requests and compute ratios. Option C is wrong because an activity log alert monitors Azure resource management events (e.g., VM creation, configuration changes), not application performance metrics like response times. Option D is wrong because Application Insights smart detection alerts use built-in machine learning models to detect anomalies automatically, but they do not allow you to define custom thresholds like '>10% of requests exceeding 5 seconds'.

Practice this question →

MCQeasy

You are monitoring an Azure Web App with Application Insights. You notice a sudden spike in failed requests. You need to quickly identify which specific URL path is causing the most failures. Which blade in the Application Insights portal should you use?

A.Application Map

B.Failures blade

C.Performance blade

D.Live Metrics Stream

AnswerB

This blade is designed for analyzing failed requests, grouped by operation name, URL, etc., making it easy to identify the most failing endpoint.

Why this answer

The Failures blade in Application Insights is specifically designed to analyze failed requests, including HTTP 4xx and 5xx errors, and provides a breakdown by URL path, response code, and failure count. This allows you to quickly identify the specific URL path causing the most failures, which directly addresses the need to pinpoint the problematic endpoint.

Exam trap

The trap here is that candidates often confuse the Failures blade with the Performance blade, assuming performance metrics (like slow requests) are the root cause of failures, but the question explicitly asks for identifying failed requests by URL path, which is the sole purpose of the Failures blade.

How to eliminate wrong answers

Option A is wrong because the Application Map visualizes the dependency flow and health of your application components, but it does not provide a granular breakdown of failed requests by URL path. Option C is wrong because the Performance blade focuses on request durations, throughput, and slow operations, not on failed request analysis. Option D is wrong because Live Metrics Stream shows real-time telemetry (e.g., request rate, CPU usage) but does not aggregate historical failure data or allow sorting by URL path.

Practice this question →

MCQmedium

An Azure App Service application has memory pressure. The developer needs distributed tracing across requests and dependencies. What should be enabled?

A.Application Insights with dependency tracking

B.Azure Policy compliance scan

C.Cost Management budgets only

D.Storage account static website logs

AnswerA

Application Insights provides request, dependency, exception, and trace telemetry for application diagnostics.

Why this answer

Application Insights with dependency tracking enables distributed tracing by automatically collecting telemetry across HTTP requests, database calls, and external service dependencies. This allows developers to correlate end-to-end transactions and identify the root cause of memory pressure, such as a specific dependency causing excessive resource consumption.

Exam trap

The trap here is that candidates may confuse Azure Policy (governance) or Cost Management (budgeting) with monitoring tools, or think static website logs can trace application dependencies, when only Application Insights provides the necessary distributed tracing and dependency correlation.

How to eliminate wrong answers

Option B is wrong because Azure Policy compliance scans enforce governance rules on resources (e.g., tagging or location restrictions) and do not provide any tracing or monitoring of application-level requests or dependencies. Option C is wrong because Cost Management budgets only track and alert on spending; they have no capability to trace distributed requests or diagnose memory pressure. Option D is wrong because Storage account static website logs capture only HTTP access logs for static content hosted in Azure Storage, not the distributed tracing of an App Service application's requests and dependencies.

Practice this question →

MCQhard

You have an App Service app that uses Azure SQL Database. Users report that some queries are slow. You need to monitor query performance and receive alerts when the average query duration exceeds 1 second. Which two Azure services should you use?

A.Azure Advisor

B.Azure Monitor Alerts

C.Azure Monitor Logs

D.Application Insights

E.Azure SQL Analytics

AnswerD, E

Application Insights can track SQL dependency calls and set alerts on duration.

Why this answer

Option B (Application Insights) and Option D (Azure SQL Analytics) are correct because Application Insights can monitor the app's SQL dependency calls and set alerts, while Azure SQL Analytics provides deep query performance insights. Option A (Azure Monitor Logs) is too broad. Option C (Azure Monitor Alerts) can be used but requires a data source.

Option E (Azure Advisor) gives recommendations but not real-time monitoring.

Practice this question →

MCQeasy

You are debugging a performance issue in a live web application monitored by Application Insights. You need to see real-time metrics such as request rate, response times, and any exceptions as they occur, without waiting for the usual telemetry pipeline. Which Application Insights feature should you use?

A.Application Insights Analytics (Log Analytics)

B.Live Metrics Stream

C.Metrics Explorer

D.Application Insights Profiler

AnswerB

Live Metrics Stream shows live, low-latency telemetry from your application, including request rates, response times, and exceptions. It is designed for real-time monitoring and debugging.

Why this answer

Live Metrics Stream (option B) is the correct feature because it provides real-time, low-latency telemetry directly from the Application Insights SDK, bypassing the usual ingestion pipeline. This allows you to monitor request rate, response times, and exceptions as they occur, which is exactly what the scenario requires for debugging a live performance issue without waiting for data to be processed.

Exam trap

The trap here is that candidates often confuse Live Metrics Stream with Metrics Explorer, assuming both provide real-time data, but Metrics Explorer relies on pre-aggregated metrics with a built-in delay, while Live Metrics Stream is the only feature designed for true sub-second live monitoring.

How to eliminate wrong answers

Option A is wrong because Application Insights Analytics (Log Analytics) is a query-based tool for analyzing historical telemetry data after it has been ingested and stored, not for real-time monitoring. Option C is wrong because Metrics Explorer displays pre-aggregated metrics with a delay (typically 1-2 minutes) and does not provide sub-second live data. Option D is wrong because Application Insights Profiler is used for tracing performance bottlenecks in specific requests via snapshots, not for continuous real-time monitoring of request rates and exceptions.

Practice this question →

MCQmedium

You have an Azure CDN profile that caches content from a storage account. Users in Europe report that images load slowly. You need to improve performance for European users. What should you do?

A.Enable compression on the CDN

B.Enable prefetching on the CDN

C.Configure caching rules to cache longer

D.Add an additional CDN endpoint with a European origin

AnswerD

Multiple endpoints with local origins can reduce latency.

Why this answer

Option C is correct because adding a CDN endpoint with a European origin or closest POP reduces latency. Option A (prefetching) is not a CDN feature. Option B (compression) may help but not primarily for geographic latency.

Option D (caching rules) may improve hit ratio but not geographical distance.

Practice this question →

MCQmedium

A high-traffic API sends approximately 80,000 telemetry events per second to Application Insights. Monthly ingestion costs are too high. The team wants to reduce data volume by roughly 80 percent while still seeing representative samples of all request types. What should the developer configure?

A.Enable adaptive sampling in the Application Insights SDK and set a target events-per-second limit

B.Configure ingestion sampling in the Azure portal to retain 20 percent of incoming telemetry

C.Increase the TelemetryClient flush interval from 30 seconds to 5 minutes to batch events

D.Filter all events with HTTP status code 200 from the telemetry pipeline before sending

AnswerA

Adaptive sampling runs in the SDK. It monitors the outgoing telemetry rate and automatically raises or lowers the sample percentage to stay near the target rate. All operation types are sampled proportionally, so statistical trends remain meaningful even at 20 percent of raw volume. Data is reduced before transmission, lowering both network and ingestion costs.

Why this answer

Adaptive sampling in the Application Insights SDK automatically adjusts the volume of telemetry sent to the service, targeting a specified rate of events per second. By setting a target that reduces the original 80,000 events/sec to roughly 20%, the SDK will intelligently sample all request types proportionally, preserving representative data while cutting costs.

Exam trap

The trap here is that candidates confuse ingestion sampling (a portal-level fixed filter) with adaptive sampling (an SDK-level dynamic filter), assuming any sampling in the portal will suffice, but only adaptive sampling can meet the dual goals of volume reduction and representativeness across all request types.

How to eliminate wrong answers

Option B is wrong because ingestion sampling in the Azure portal is a fixed-rate filter applied after telemetry is already sent, which does not reduce network and SDK overhead, and it cannot adapt to traffic spikes or maintain representativeness across all request types. Option C is wrong because increasing the flush interval only batches events into larger payloads, reducing the number of HTTP calls but not the total number of events ingested, so it does not reduce data volume or cost. Option D is wrong because filtering all HTTP 200 status codes would discard successful requests entirely, losing critical health and performance data and violating the requirement to see representative samples of all request types.

Practice this question →

MCQmedium

An Azure App Service application has availability failures. The developer needs distributed tracing across requests and dependencies. What should be enabled?

A.Application Insights with dependency tracking

B.Storage account static website logs

C.Azure Policy compliance scan

D.Cost Management budgets only

AnswerA

Application Insights provides request, dependency, exception, and trace telemetry for application diagnostics.

Why this answer

Application Insights with dependency tracking is the correct choice because it provides distributed tracing across requests and dependencies in an Azure App Service application. It automatically collects telemetry data, including end-to-end transaction details, and maps dependencies like SQL databases, HTTP calls, and Azure services, enabling developers to diagnose availability failures by correlating traces across components.

Exam trap

The trap here is that candidates may confuse general monitoring tools (like logs or compliance) with the specific need for distributed tracing, overlooking that only Application Insights with dependency tracking provides the correlation and dependency mapping required for diagnosing availability failures across requests and dependencies.

How to eliminate wrong answers

Option B is wrong because Storage account static website logs only capture HTTP request logs for static content hosted in Azure Storage, not distributed tracing across application dependencies or requests. Option C is wrong because Azure Policy compliance scan evaluates resource configurations against policies for governance and compliance, not for monitoring application performance or tracing distributed requests. Option D is wrong because Cost Management budgets only track and alert on spending, providing no telemetry or tracing capabilities for application availability or dependencies.

Practice this question →

MCQeasy

You need to monitor the CPU utilization of an Azure VM in real-time and set up an alert when it exceeds 90%. Which Azure Monitor feature should you use?

A.Log Analytics Workspace

B.Metrics Explorer

C.Application Insights

D.Azure Monitor for VMs

AnswerB

Correct. Metrics Explorer provides near real-time platform metrics and supports creating metric alerts.

Why this answer

Metrics Explorer is the correct Azure Monitor feature for real-time monitoring of CPU utilization on an Azure VM because it provides near real-time metric collection (typically every 1 minute) and supports alerting based on threshold conditions. It allows you to chart performance counters like Percentage CPU and configure metric alerts that trigger when the value exceeds 90%.

Exam trap

The trap here is that candidates often confuse Azure Monitor for VMs (which provides a dashboard view) with the actual alerting mechanism, or they mistakenly think Log Analytics is needed for metric alerts when Metrics Explorer handles them directly.

How to eliminate wrong answers

Option A is wrong because Log Analytics Workspace is designed for collecting and querying log data (e.g., Windows Event Logs, Syslog) using KQL, not for real-time metric monitoring or threshold-based alerts on CPU utilization. Option C is wrong because Application Insights is an Application Performance Management (APM) service focused on monitoring live web applications, not infrastructure-level metrics like VM CPU utilization. Option D is wrong because Azure Monitor for VMs (now VM Insights) provides a pre-built experience with performance charts and dependency mapping, but it relies on underlying Metrics Explorer for alerting and is not the direct feature for setting a metric alert on CPU utilization.

Practice this question →

Multi-Selecteasy

Which TWO actions can help you reduce latency for a globally distributed web application? (Choose two.)

Select 2 answers

A.Use Azure Application Gateway with Web Application Firewall

B.Scale up the App Service plan to a higher tier

C.Use Azure Traffic Manager with performance routing

D.Enable multi-region writes on Azure Cosmos DB

E.Use Azure Front Door to route traffic to the nearest region

AnswersC, E

Traffic Manager routes users to the closest region.

Why this answer

Option A (Azure Front Door) and Option D (Azure Traffic Manager) are correct because they route traffic to the nearest endpoint. Option B (App Service scaling) helps with load but not geographic latency. Option C (Cosmos DB multi-region writes) reduces database latency but not overall application latency.

Option E (Application Gateway) is regional.

Practice this question →

MCQhard

Application Insights ingestion cost is rising because a high-traffic app emits large telemetry volume. The team needs statistically useful telemetry while reducing ingestion. What should be configured? The architecture review board prefers a managed AWS-native control.

A.Move the app to a larger App Service plan

B.Adaptive sampling

C.Disable all exception telemetry

D.Increase log verbosity to debug

AnswerB

Adaptive sampling reduces telemetry volume while preserving representative diagnostic data.

Why this answer

Adaptive sampling in Application Insights automatically reduces the volume of telemetry data sent from high-traffic apps by intelligently selecting a representative subset of events. This preserves statistical utility for analysis while significantly lowering ingestion costs, making it the ideal solution for the described scenario.

Exam trap

The trap here is that candidates may confuse sampling with other cost-reduction methods like scaling up or disabling telemetry, not realizing that adaptive sampling is the only option that balances cost reduction with statistical validity.

How to eliminate wrong answers

Option A is wrong because moving to a larger App Service plan increases compute resources but does not reduce telemetry volume or ingestion costs; it may even increase costs. Option C is wrong because disabling all exception telemetry would eliminate critical diagnostic data, undermining the team's need for statistically useful telemetry. Option D is wrong because increasing log verbosity to debug would dramatically increase telemetry volume, worsening the ingestion cost problem.

Practice this question →

MCQeasy

You are monitoring an Azure web application with Application Insights. You notice a sudden increase in the number of failed requests. You want to be notified automatically when such anomalies occur, without manually setting static thresholds. Which Application Insights feature should you use?

A.Create a metric alert on the 'failed requests' metric with a static threshold.

B.Enable Smart Detection for failure anomalies.

C.Use Log Analytics to run a query every 5 minutes and trigger an action.

D.Create an availability test that periodically pings the application.

AnswerB

Correct. Smart Detection automatically analyzes telemetry and alerts on anomalous patterns, such as a sudden spike in failed requests.

Why this answer

Smart Detection for failure anomalies in Application Insights uses machine learning to automatically detect unusual patterns in failed request rates without requiring manual threshold configuration. This feature is specifically designed to notify you of anomalies based on historical behavior, making it the correct choice for the scenario described.

Exam trap

The trap here is that candidates often confuse metric alerts with static thresholds as the only way to get notified, overlooking the machine learning-based Smart Detection feature that is purpose-built for anomaly detection without manual thresholds.

How to eliminate wrong answers

Option A is wrong because creating a metric alert with a static threshold requires manual configuration and does not adapt to changing traffic patterns, which contradicts the requirement to avoid setting static thresholds. Option C is wrong because using Log Analytics to run a query every 5 minutes is a custom, manual approach that lacks the built-in anomaly detection capabilities of Smart Detection and requires additional setup for scheduling and action groups. Option D is wrong because an availability test periodically pings the application to check endpoint availability, not to detect anomalies in failed request rates; it is designed for availability monitoring, not for analyzing historical failure patterns.

Practice this question →

MCQmedium

Your Azure Logic Apps workflow fails intermittently with timeout errors. What should you do to improve reliability?

A.Configure retry policies for failed actions

B.Increase the action timeout to maximum

C.Reduce the number of parallel branches

D.Use Azure API Management in front of Logic Apps

AnswerA

Retries handle transient failures.

Why this answer

Option D is correct because configuring retry policies handles transient failures. Option A is wrong because increasing timeout doesn't fix the root cause. Option B is wrong because it's for other services.

Option C is wrong because it reduces parallelism, not reliability.

Practice this question →

MCQmedium

An e-commerce application emits a high volume of telemetry data to Azure Application Insights. You need to reduce the cost of data ingestion while preserving statistical accuracy for performance metrics. Which sampling technique should you use?

A.Adaptive sampling

B.Fixed-rate sampling with a 1% rate

C.Ingestion sampling

D.Head-based sampling

AnswerA

Adaptive sampling dynamically tunes the sampling rate to keep data volume manageable while preserving statistical validity.

Why this answer

Adaptive sampling is the correct choice because it automatically adjusts the sampling rate based on the volume of telemetry data, ensuring that during low-traffic periods all data is retained for statistical accuracy, while during high-traffic periods it reduces the rate to control costs. This technique is specifically designed for high-volume scenarios like e-commerce telemetry, where preserving statistical accuracy for performance metrics (e.g., request durations, failure rates) is critical, and it avoids the manual tuning required by fixed-rate sampling.

Exam trap

The trap here is that candidates often confuse adaptive sampling with fixed-rate sampling, assuming a constant low rate (like 1%) is always cheaper, but they miss that adaptive sampling preserves accuracy by retaining all data during low-volume periods and only reduces during spikes.

How to eliminate wrong answers

Option B is wrong because fixed-rate sampling with a 1% rate applies a constant sampling percentage regardless of traffic volume, which can lead to under-sampling during low-traffic periods (losing statistical accuracy) or over-sampling during high-traffic periods (not reducing costs effectively). Option C is wrong because ingestion sampling occurs at the Application Insights ingestion endpoint after telemetry is sent, meaning you still pay for the data transmitted to the endpoint, and it does not reduce network bandwidth or SDK-side processing costs. Option D is wrong because head-based sampling (e.g., fixed-rate sampling at the SDK level) samples telemetry before any processing, which can break end-to-end transaction correlation if not all components use the same sampling rate, and it does not adapt to changing traffic patterns.

Practice this question →

MCQhard

You need to reduce costs for an Azure Functions app that runs intermittently. The current Consumption plan bills for execution time. Which change would be MOST cost-effective?

A.Switch to Premium plan with pre-warmed instances

B.Migrate to Flex Consumption plan with higher memory

C.Use an App Service plan with Always On

D.Deploy to Azure Container Instances

AnswerB

Flex Consumption allows memory optimization to reduce execution time and cost.

Why this answer

Option B is correct because the Flex Consumption plan allows choosing higher memory which can reduce execution time for CPU-bound tasks, lowering cost. Option A is wrong because Premium plan has a fixed cost. Option C is wrong because Dedicated plan is more expensive for intermittent usage.

Option D is wrong because App Service plan is not suitable for Functions.

Practice this question →

MCQmedium

Refer to the exhibit. You run this KQL query in Azure Monitor Logs. What does the timechart display?

A.Multiple lines, one for each result code, showing request count over time

B.A single line of total requests over time

C.Total requests per 5 minutes

D.Requests grouped by result code only

AnswerA

The render timechart will show separate series per resultCode.

Why this answer

Option D is correct because the query groups requests by 5-minute bins and result code, so the chart shows separate series for each result code. Option A is wrong because it aggregates over all result codes. Option B is wrong because it includes all result codes separately.

Option C is wrong because it's not total requests but per result code.

Practice this question →

100

MCQmedium

You manage a web application hosted on Azure App Service. You need to monitor the application's availability from multiple geographic locations. The test should check that the homepage loads successfully and returns HTTP 200 within 5 seconds. You want to receive an alert if the test fails from any location. Which type of Application Insights test should you create?

A.Multi-step web test

B.URL ping test

C.Custom availability test using TrackAvailability

D.Continuous export test

AnswerB

A URL ping test checks a single URL from multiple locations and can alert based on response time and HTTP status code, perfectly matching the requirements.

Why this answer

The URL ping test is the correct choice because it is a simple, single-URL availability test that checks whether a specific endpoint (the homepage) returns HTTP 200 within a specified timeout (5 seconds). It can be configured to run from multiple geographic locations and trigger an alert on failure, meeting all requirements without the complexity of multi-step or custom code.

Exam trap

The trap here is that candidates often confuse the URL ping test with the multi-step web test, assuming that any availability check requires a multi-step test, but the URL ping test is specifically designed for single-URL validation with geographic distribution and alerting.

How to eliminate wrong answers

Option A is wrong because a multi-step web test is designed to validate a sequence of user actions (e.g., login, navigate, submit) across multiple URLs, which is overkill and unnecessary for a simple homepage load check. Option C is wrong because TrackAvailability is a custom method used in code to report availability results manually, requiring you to write and deploy custom application logic, which is not needed for a basic HTTP 200 check. Option D is wrong because continuous export is a feature for exporting Application Insights telemetry data to storage or Event Hubs, not a mechanism for creating or running availability tests.

Practice this question →

101

MCQeasy

You have enabled Application Insights on your Azure Web App. You notice that some server-side exceptions are not appearing in the Application Insights portal. What is the most likely reason?

A.The Application Insights SDK is not installed in the application

B.The developer forgot to set the Instrumentation Key in the application configuration

C.The web app is running on a Free tier App Service plan

D.The exceptions are being caught and handled in code without being re-thrown or explicitly logged

AnswerD

Caught exceptions that are not re-thrown or logged via TrackException are not automatically tracked. Developers must explicitly log handled exceptions to see them in Application Insights.

Why this answer

Option D is correct because Application Insights only captures exceptions that are unhandled or explicitly logged via the SDK. If an exception is caught in a try-catch block and not re-thrown or logged using `TelemetryClient.TrackException()`, it will not appear in the portal. This is a common oversight when developers handle exceptions silently without instrumentation.

Exam trap

The trap here is that candidates assume enabling Application Insights on the Azure portal automatically captures all exceptions, but in reality, caught exceptions require explicit logging via the SDK.

How to eliminate wrong answers

Option A is wrong because the question states that Application Insights is enabled on the Azure Web App, which implies the SDK is installed (e.g., via the App Insights extension or auto-instrumentation). Option B is wrong because if the Instrumentation Key were missing, no telemetry at all would appear, not just missing server-side exceptions. Option C is wrong because the Free tier App Service plan does not prevent exception telemetry from being sent; it only limits compute resources and does not affect Application Insights data collection.

Practice this question →

102

Multi-Selectmedium

Which TWO approaches can help you optimize the cost of Azure Storage accounts that store infrequently accessed data? (Choose two.)

Select 2 answers

A.Use Cool or Archive storage tier

B.Use Premium storage tier

C.Enable geo-redundant storage (RA-GRS)

D.Configure lifecycle management to move blobs to cooler tiers

E.Enable Azure Storage encryption

AnswersA, D

Cool and Archive tiers are cheaper for infrequent access.

Why this answer

Option B (Cool storage tier) and Option D (lifecycle management) are correct. Option A (premium tier) is for high-performance, more expensive. Option C (RA-GRS) adds cost.

Option E (encryption) doesn't affect cost.

Practice this question →

103

MCQeasy

You need to monitor the performance of an Azure web app. You want to track the average response time and the number of failed requests over the last hour. Which Azure service should you use?

A.Application Insights

B.Azure Monitor

C.Log Analytics

D.Azure Advisor

AnswerA

Correct. Application Insights monitors your live application and collects performance metrics, including response times and failure rates.

Why this answer

Application Insights is the correct choice because it is an extensible Application Performance Management (APM) service designed specifically for monitoring live web applications. It can track metrics like average response time and failed request counts out of the box, and it integrates directly with Azure Web Apps via the Application Insights SDK or auto-instrumentation, providing real-time telemetry without requiring custom logging code.

Exam trap

The trap here is that candidates often confuse Azure Monitor (the umbrella service) with Application Insights, assuming Azure Monitor alone can track application-level metrics like response time, when in fact it requires Application Insights for that granular, code-level telemetry.

How to eliminate wrong answers

Option B (Azure Monitor) is wrong because while it collects and stores platform-level metrics and logs (e.g., CPU, memory), it does not natively capture application-level metrics like average response time or failed request counts without additional configuration or integration with Application Insights. Option C (Log Analytics) is wrong because it is a query and analysis tool for log data stored in Log Analytics workspaces, not a real-time application performance monitoring service; it lacks built-in application telemetry collection. Option D (Azure Advisor) is wrong because it is a personalized cloud consultant that provides best practice recommendations for cost, security, reliability, and performance, but it does not collect or display live application performance metrics such as response time or failure counts.

Practice this question →

104

MCQmedium

Users of a web application hosted on App Service are randomly signed out when the app is scaled out to three instances. Investigation shows that session data stored in in-process memory is not available when subsequent requests hit a different instance. What is the recommended solution?

A.Store session data in Azure Cache for Redis and configure all App Service instances to connect to the same Redis endpoint

B.Enable ARR affinity (sticky sessions) on the App Service to route each user's requests to the same instance

C.Write session data to Azure Blob Storage as a JSON file keyed by session ID on every request

D.Store session state in a Cosmos DB container with a TTL equal to the session timeout

AnswerA

Redis acts as a shared external session store. Each instance serializes the session to Redis on write and deserializes it on read. Because all instances point to the same Redis instance, any instance can serve any user's requests correctly, making the session store horizontally scalable and instance-independent.

Why this answer

When an App Service scales out to multiple instances, in-process session state is stored locally on each instance and is not shared. Azure Cache for Redis provides a centralized, in-memory data store that all instances can access, ensuring session data is available regardless of which instance handles a request. This is the recommended pattern for distributed session state in Azure.

Exam trap

The trap here is that candidates often confuse ARR affinity (sticky sessions) as a complete solution, not realizing it only masks the problem by pinning users to instances, but fails to provide resilience against instance failures or scaling operations.

How to eliminate wrong answers

Option B is wrong because enabling ARR affinity (sticky sessions) only routes requests from the same user to the same instance, but it does not solve the underlying problem of session data loss if that instance fails or is recycled, and it can lead to uneven load distribution. Option C is wrong because writing session data to Azure Blob Storage on every request introduces high latency and is not designed for low-latency, high-frequency session reads/writes; it is a file storage service, not a session store. Option D is wrong because Cosmos DB is a NoSQL database with higher latency and cost compared to Redis for session state, and its TTL feature is for document expiration, not for efficient session management; it is overkill and not the recommended solution for this scenario.

Practice this question →

105

MCQmedium

You are developing a solution that uses Azure Functions with a consumption plan. The function processes messages from an Azure Service Bus queue. During a load test, you notice that the function takes a long time to start processing messages after a period of inactivity. What is the most likely cause of this cold start delay?

A.The function is using a consumption plan, which may scale to zero instances.

B.The function timeout is set too low.

C.The function is using a premium plan with pre-warmed instances.

D.The Service Bus namespace is using the Premium tier.

AnswerA

Consumption plan scales to zero, causing cold starts on first request after inactivity.

Why this answer

Option C is correct because the consumption plan can cause cold starts after inactivity due to scaling down to zero instances. Option A is incorrect because Service Bus Premium does not affect function cold starts. Option B is incorrect because the function timeout does not cause cold starts.

Option D is incorrect because premium plans reduce cold starts, not cause them.

Practice this question →

106

MCQhard

Application Insights ingestion cost is rising because a high-traffic app emits large telemetry volume. The team needs statistically useful telemetry while reducing ingestion. What should be configured? The design must avoid adding custom operational scripts.

A.Move the app to a larger App Service plan

B.Adaptive sampling

C.Disable all exception telemetry

D.Increase log verbosity to debug

AnswerB

Adaptive sampling reduces telemetry volume while preserving representative diagnostic data.

Why this answer

Adaptive sampling is the correct solution because it automatically adjusts the volume of telemetry data collected from your application, ensuring that only a representative fraction of events is sent to Application Insights while preserving statistical accuracy for analysis. This reduces ingestion costs without requiring custom scripts or manual intervention, as it is a built-in feature of the Application Insights SDK that dynamically adapts based on traffic patterns.

Exam trap

The trap here is that candidates often confuse scaling (Option A) with cost optimization, or they mistakenly believe that disabling all telemetry (Option C) is a valid cost-saving measure, when in fact adaptive sampling provides a balanced approach that maintains data utility without manual overhead.

How to eliminate wrong answers

Option A is wrong because moving to a larger App Service plan increases compute resources but does not reduce telemetry volume or ingestion costs; it only addresses performance scaling, not data management. Option C is wrong because disabling all exception telemetry would eliminate critical diagnostic data needed for monitoring application health, potentially masking issues and violating the requirement for statistically useful telemetry. Option D is wrong because increasing log verbosity to debug would generate even more telemetry data, exacerbating the ingestion cost problem rather than solving it.

Practice this question →

107

Multi-Selecthard

A production API needs proactive alerting for unexpected exceptions. Which two elements are required for a useful Azure Monitor alert?

Select 2 answers

A.A signal or metric/log query that detects the condition

B.An action group for notification or automation

C.A public IP address on the app

D.A manually exported CSV report

AnswersA, B

The alert rule must evaluate a metric or query that represents the problem.

Why this answer

A is correct because an Azure Monitor alert requires a signal (such as a metric, log query, or activity log event) to define the condition that triggers the alert. Without a signal, the alert has no basis for evaluation, making it impossible to detect unexpected exceptions proactively.

Exam trap

The trap here is that candidates may think a public IP or exported report is needed for monitoring, but Azure Monitor alerts only require a signal and an action group, not network-level or manual data exports.

Practice this question →

108

MCQmedium

An Azure App Service application has slow API requests. The developer needs distributed tracing across requests and dependencies. What should be enabled?

A.Azure Policy compliance scan

B.Application Insights with dependency tracking

C.Storage account static website logs

D.Cost Management budgets only

AnswerB

Application Insights provides request, dependency, exception, and trace telemetry for application diagnostics.

Why this answer

Application Insights with dependency tracking is the correct choice because it provides distributed tracing across requests and dependencies, enabling developers to correlate end-to-end transactions in a microservices or multi-component application. It automatically collects telemetry for HTTP calls, database queries, and other external service calls, which is essential for diagnosing slow API requests in an Azure App Service environment.

Exam trap

The trap here is that candidates may confuse Azure Policy or storage logs with monitoring tools, but only Application Insights provides the distributed tracing and dependency correlation needed for diagnosing slow API requests across multiple components.

How to eliminate wrong answers

Option A is wrong because Azure Policy compliance scan enforces organizational rules and governance on Azure resources, but it does not collect runtime telemetry or trace requests across dependencies. Option C is wrong because Storage account static website logs capture HTTP access logs for static content hosted in blob storage, not distributed tracing for dynamic API requests in App Service. Option D is wrong because Cost Management budgets only track and alert on spending, providing no insight into application performance or dependency call chains.

Practice this question →

109

MCQmedium

A developer needs to run a Kusto query against application request data to identify 95th percentile latency by operation. Where should the query be run?

A.Logs in Application Insights or the associated Log Analytics workspace

B.Microsoft Entra audit logs

C.Azure Key Vault diagnostic settings

D.Azure Resource Graph only

AnswerA

Application Insights stores telemetry that can be queried with KQL in Logs.

Why this answer

Application Insights stores application request data, including latency metrics, and supports Kusto queries via its Logs blade. The associated Log Analytics workspace also provides the same query capabilities, making it the correct location to run a Kusto query for 95th percentile latency by operation.

Exam trap

The trap here is that candidates may confuse Azure Resource Graph with Log Analytics, but Resource Graph only queries Azure resource properties and configurations, not application telemetry data.

How to eliminate wrong answers

Option B is wrong because Microsoft Entra audit logs contain sign-in and directory activity, not application request latency data. Option C is wrong because Azure Key Vault diagnostic settings capture vault access and performance logs, not application request metrics. Option D is wrong because Azure Resource Graph is designed for resource inventory and configuration queries across subscriptions, not for querying application telemetry like request latency.

Practice this question →

110

MCQhard

You have an Azure App Service web app that experiences intermittent slowness. You enable Application Insights and notice that the "Failed Requests" metric is low, but "Server Response Time" is high for a subset of requests. You want to identify the specific code path causing the delay. Which feature should you use?

A.Live Metrics.

B.Snapshot Debugger.

C.Profiler.

D.Availability tests.

AnswerC

Correct. Profiler traces requests and identifies slow code paths.

Why this answer

C is correct because the Application Insights Profiler captures detailed call stacks and execution timing for slow requests, allowing you to pinpoint the exact code path causing high server response time. Unlike other features, Profiler is specifically designed for performance troubleshooting by tracing request execution at the code level.

Exam trap

The trap here is confusing the Profiler (for performance diagnostics) with the Snapshot Debugger (for exception debugging), leading candidates to choose Snapshot Debugger when the question explicitly asks about identifying the cause of high response times, not failures.

How to eliminate wrong answers

Option A is wrong because Live Metrics provides real-time monitoring of metrics like request rate and response times but does not capture detailed code-level call stacks to identify the specific slow code path. Option B is wrong because Snapshot Debugger is designed to capture debug snapshots on exceptions, not for analyzing slow response times; it helps diagnose crashes, not performance bottlenecks. Option D is wrong because Availability tests monitor the endpoint's availability and responsiveness from external locations, but they do not provide code-level profiling to identify the internal code path causing delays.

Practice this question →

111

MCQhard

You are monitoring an Azure App Service using Application Insights. You notice that HTTP 500 errors are increasing, but the standard server response time metric remains normal. You suspect that the errors are occurring in an external API call made by the application. How can you identify the dependency that is failing?

A.Enable snapshot debugging for the application.

B.Use Application Insights Profiler to capture code-level traces.

C.Configure Application Insights dependency tracking and view the Dependency Metrics blade.

D.Set up a custom event telemetry for each external call.

AnswerC

Dependency tracking records each call to external services, and the metrics blade aggregates failures and durations for each dependency, making it easy to spot failures.

Why this answer

Option C is correct because Application Insights dependency tracking automatically monitors HTTP calls, SQL queries, and other external dependencies made by your application. By viewing the Dependency Metrics blade, you can see failure rates, durations, and dependency names, allowing you to identify which external API call is failing without modifying code.

Exam trap

The trap here is that candidates may confuse dependency tracking with custom event telemetry or think that snapshot debugging or profiling can identify external API failures, but only dependency tracking provides automatic, aggregated metrics for outbound calls.

How to eliminate wrong answers

Option A is wrong because snapshot debugging captures the state of the application when exceptions occur, but it does not provide aggregated metrics or dependency-specific failure data; it is for debugging individual exceptions, not for identifying failing dependencies. Option B is wrong because Application Insights Profiler captures code-level traces and performance bottlenecks within your application's own code, not external API calls; it focuses on CPU time and request processing, not dependency failures. Option D is wrong because setting up custom event telemetry for each external call would require manual instrumentation and code changes, whereas dependency tracking is automatic and provides built-in metrics; custom events add overhead and are not necessary when dependency tracking is available.

Practice this question →

112

MCQmedium

You are monitoring an Azure web application with Application Insights. You need to identify the top 5 slowest API endpoints over the last 7 days. The results should show the endpoint URL, average response time, and request count. Which feature or query should you use?

A.Use Log Analytics and run a query on the 'requests' table to aggregate by URL and sort by avg(duration).

B.Use the 'Performance' blade under 'Investigate' in the Application Insights resource.

C.Use the 'Application Map' feature to visualize dependencies and endpoints.

D.Configure Smart Detection to automatically identify slow API endpoints.

AnswerB

The Performance blade is specifically designed for this purpose. It shows the top operations (requests) by their average duration over a selected time range, along with request count and other metrics.

Why this answer

Option B is correct because the 'Performance' blade in Application Insights provides a pre-built, optimized view that automatically aggregates request data by endpoint URL, displaying average response time and request count. It allows you to sort by average duration to quickly identify the top 5 slowest API endpoints over the last 7 days without writing any custom query.

Exam trap

The trap here is that candidates often assume Log Analytics is always the best tool for any custom aggregation, overlooking that Application Insights provides purpose-built blades (like Performance) that offer the same functionality with zero query effort and faster results.

How to eliminate wrong answers

Option A is wrong because while Log Analytics can query the 'requests' table, it requires writing a Kusto query manually (e.g., 'requests | summarize avg(duration) by url | top 5 by avg_duration desc'), which is more complex and time-consuming than using the built-in Performance blade. Option C is wrong because the Application Map visualizes dependencies and call flows between components, not aggregated performance metrics like average response time and request count for endpoints. Option D is wrong because Smart Detection is an automated alerting feature that proactively identifies anomalies (e.g., sudden degradation), not a tool for manually querying historical top-N slowest endpoints over a fixed period.

Practice this question →

113

MCQmedium

You are monitoring an Azure Web App with Application Insights. You notice that certain requests have high server response times. You need to identify which specific database queries are causing the delays. Which Application Insights feature should you use?

A.Application Insights Profiler

B.Live Metrics Stream

C.Performance blade

D.Application Map

AnswerA

Correct. Profiler traces end-to-end requests, showing the duration of each dependency call, including database queries, at the individual query level.

Why this answer

Application Insights Profiler is the correct feature because it provides detailed, code-level diagnostics for requests with high server response times, including per-operation breakdowns of database query durations. It captures execution traces that show exactly which SQL queries or external calls are contributing to latency, enabling you to pinpoint the specific database queries causing delays.

Exam trap

The trap here is that candidates often confuse the Performance blade (which shows aggregated dependency durations) with the Profiler (which provides per-request, code-level traces), leading them to choose the Performance blade when they need to identify specific slow queries rather than overall trends.

How to eliminate wrong answers

Option B (Live Metrics Stream) is wrong because it shows real-time metrics like request rate and failure counts but does not provide per-query profiling or detailed database query timings. Option C (Performance blade) is wrong because it aggregates performance data (e.g., average response times, dependency durations) but lacks the granular, per-request trace-level detail needed to identify specific slow queries. Option D (Application Map) is wrong because it visualizes the topology and dependencies of your application components but does not drill into individual query execution times or provide profiling data.

Practice this question →

114

Multi-Selectmedium

Which TWO actions should you take to reduce the cost of an Azure App Service plan that is underutilized?

Select 2 answers

A.Deploy the application to a different region

B.Enable auto-scaling

C.Purchase Reserved Instances

D.Scale out to fewer instances

E.Scale down the App Service plan to a lower tier

AnswersD, E

Fewer instances reduce cost.

Why this answer

Options B and D are correct. Scaling down to a lower tier reduces cost. Scaling out to fewer instances also reduces cost.

Option A is wrong because enabling auto-scaling may increase cost if it scales out. Option C is wrong because Reserved Instances require a commitment. Option E is wrong because deploying to a different region may not reduce cost.

Practice this question →

115

MCQmedium

After deploying a new version to the staging slot and swapping to production, users report a 60-second spike in 503 errors. The application takes 45 seconds to initialize its connection pools and caches before it can serve traffic. What is the root cause, and what should the developer configure to prevent this?

A.Configure Application Initialization in the App Service settings so the swap waits for the warm-up path to return 200 before redirecting production traffic

B.Roll back the slot swap and investigate the new version for bugs that only appear in production

C.Increase the App Service health check grace period so the load balancer waits longer after the swap

D.Disable Always On for the staging slot so the slot starts fresh on every swap

AnswerA

Application Initialization instructs the App Service platform to send a warm-up request to a configured URL path after the slot starts and before the swap completes. The platform holds traffic on the old slot until the warm-up succeeds. This makes swaps zero-downtime even for applications with long initialization times.

Why this answer

The root cause is that the swap operation immediately redirects production traffic to the new slot before the application has finished its 45-second initialization (connection pools, caches). Application Initialization (warm-up) in Azure App Service can be configured to send a request to a specified path and wait for a 200 response before completing the swap, ensuring the app is ready to serve traffic. This eliminates the 503 errors by preventing the swap from routing users to an uninitialized instance.

Exam trap

The trap here is that candidates confuse the health check feature (which monitors instance health after traffic is routed) with Application Initialization (which delays the swap until the app is ready), leading them to incorrectly choose Option C.

How to eliminate wrong answers

Option B is wrong because the issue is not a bug in the new version—the application initializes successfully after 45 seconds, and the 503 errors only occur during the swap window, indicating a warm-up timing problem, not a code defect. Option C is wrong because the health check grace period controls how long the load balancer waits before marking an instance as unhealthy after a failed health check; it does not delay the swap itself or wait for the app to initialize before routing traffic. Option D is wrong because disabling Always On would cause the staging slot to cold-start on every swap, which would actually increase initialization time and worsen the 503 spike, not prevent it.

Practice this question →

116

MCQmedium

You are developing a web app that experiences intermittent slow responses. You enable Application Insights and notice that the server-side request duration is normally under 200ms, but some requests take over 5 seconds. Which diagnostic tool should you use to identify the root cause?

A.Availability Tests

B.Application Insights Profiler

C.Snapshot Debugger

D.Live Metrics Stream

AnswerB

Profiler traces code-level performance to identify slow operations.

Why this answer

Option B is correct because Profiler traces the specific line of code that causes slow requests. Option A (Snapshot Debugger) is for exceptions, not performance. Option C (Live Metrics) shows real-time data but doesn't pinpoint code.

Option D (Availability Tests) checks endpoint availability, not performance.

Practice this question →