Home > Docs > Features > Fabric Unified Admin Monitoring

📊 Fabric Unified Admin Monitoring (FUAM) - Tenant-Wide Observability¶

Last Updated: 2026-04-27 | Version: 1.0.0

Table of Contents¶

• Overview
• Architecture
• Admin Monitoring Workspace
• Key Metrics and Tables
• KQL Queries for Capacity Analytics
• Custom Admin Dashboards
• Alerting on Capacity Anomalies
• Comparison: FUAM vs Workspace Monitoring
• RBAC for Admin Monitoring
• Casino Implementation
• Federal Agency Implementation
• Limitations
• References

Overview¶

Fabric Unified Admin Monitoring (FUAM) is a tenant-level observability solution that auto-provisions a dedicated monitoring workspace containing a semantic model, a Lakehouse, and pre-built reports. It gives Fabric administrators visibility into capacity utilization, throttling, item execution, user activity, and cost allocation across every workspace in the tenant.

Unlike Workspace Monitoring (which focuses on individual item-level telemetry within a single workspace), FUAM provides the platform-wide view that capacity admins and FinOps teams need to manage costs, enforce governance, and plan capacity.

FUAM vs Capacity Metrics App (Legacy)¶

Architecture¶

graph TB
    subgraph "Fabric Tenant"
        C1[Capacity A - F64]
        C2[Capacity B - F32]
        W1[Workspace 1]
        W2[Workspace 2]
        W3[Workspace 3]
    end

    subgraph "Admin Monitoring Workspace (Auto-Provisioned)"
        LH[Lakehouse: AdminMonitoring]
        SM[Semantic Model: CapacityMetrics]
        RPT[Report: Admin Dashboard]
    end

    C1 --> LH
    C2 --> LH
    W1 --> LH
    W2 --> LH
    W3 --> LH

    LH --> SM --> RPT

    subgraph "Consumers"
        ADMIN[Fabric Admin]
        FINOPS[FinOps Team]
        SEC[Security Team]
    end

    RPT --> ADMIN
    RPT --> FINOPS
    RPT --> SEC

Data Flow¶

1. Telemetry collection: Fabric platform emits CU consumption, operation logs, and user activity events
2. Lakehouse ingestion: Events land in the Admin Monitoring Lakehouse as Delta tables
3. Semantic model: Auto-provisioned model with pre-built measures and relationships
4. Reports: Pre-built dashboards surface key metrics; you can build custom ones

Admin Monitoring Workspace¶

Enabling FUAM¶

1. Navigate to Admin Portal > Tenant Settings > Admin Monitoring
2. Enable Admin Monitoring Workspace
3. Select the capacity to host the monitoring workspace
4. Wait ~15 minutes for auto-provisioning

Auto-Provisioned Assets¶

Key Metrics and Tables¶

Core Tables in the Lakehouse¶

Key DAX Measures (Pre-Built)¶

// Total CU consumption for selected period
Total CU Consumed =
SUM(capacity_operations[CUSeconds]) / 3600

// Throttling rate
Throttling Rate =
DIVIDE(
    COUNTROWS(FILTER(capacity_metrics_hourly, [ThrottlingPercent] > 0)),
    COUNTROWS(capacity_metrics_hourly),
    0
)

// Top consumer workspace
Top Workspace =
TOPN(
    1,
    SUMMARIZE(
        capacity_operations,
        capacity_operations[WorkspaceName],
        "TotalCU", SUM(capacity_operations[CUSeconds])
    ),
    [TotalCU], DESC
)

// Cost allocation per workspace (assuming $0.36/CU-hour for F64)
Workspace Cost =
SUMX(
    capacity_operations,
    capacity_operations[CUSeconds] / 3600 * 0.36
)

KQL Queries for Capacity Analytics¶

When FUAM data is also routed to an Eventhouse (for real-time capacity analytics), use KQL:

// Top 10 most expensive operations in the last 24 hours
capacity_operations
| where StartTime > ago(24h)
| summarize TotalCU = sum(CUSeconds) by ItemType, ItemName, WorkspaceName
| top 10 by TotalCU desc
| extend TotalCUHours = round(TotalCU / 3600.0, 2)
| project WorkspaceName, ItemType, ItemName, TotalCUHours

// Hourly CU consumption trend with throttling overlay
capacity_metrics_hourly
| where Hour > ago(7d)
| summarize
    AvgCU = avg(CUConsumed),
    MaxCU = max(CUConsumed),
    ThrottleEvents = countif(ThrottlingPercent > 0)
    by bin(Hour, 1h), CapacityId
| render timechart

// Detect capacity spike anomalies (>2 std dev above mean)
let baseline = capacity_metrics_hourly
    | where Hour between(ago(30d) .. ago(1d))
    | summarize AvgCU = avg(CUConsumed), StdCU = stdev(CUConsumed) by CapacityId;
capacity_metrics_hourly
| where Hour > ago(1d)
| join kind=inner baseline on CapacityId
| where CUConsumed > AvgCU + 2 * StdCU
| project Hour, CapacityId, CUConsumed, Threshold = AvgCU + 2 * StdCU
| order by CUConsumed desc

// User activity audit: who ran what, when
user_activities
| where Timestamp > ago(7d)
| where Activity in ("RunNotebook", "RunPipeline", "RefreshDataset", "RunQuery")
| summarize OperationCount = count() by UserId, Activity, WorkspaceName
| top 20 by OperationCount desc

// Throttling frequency by day of week and hour
throttling_events
| where StartTime > ago(30d)
| extend DayOfWeek = dayofweek(StartTime), HourOfDay = hourofday(StartTime)
| summarize ThrottleCount = count() by DayOfWeek, HourOfDay
| render heatmap

Custom Admin Dashboards¶

Building a FinOps Dashboard¶

Connect Power BI to the Admin Monitoring Lakehouse SQL endpoint and build custom measures:

// Monthly cost by workspace (F64 at $0.36/CU-hour)
Monthly Workspace Cost =
CALCULATE(
    [Total CU Consumed] * 0.36,
    DATESINPERIOD(
        'Calendar'[Date],
        MAX('Calendar'[Date]),
        -1,
        MONTH
    )
)

// Cost trend MoM
Cost MoM Change =
VAR CurrentMonth = [Monthly Workspace Cost]
VAR PriorMonth =
    CALCULATE(
        [Monthly Workspace Cost],
        DATEADD('Calendar'[Date], -1, MONTH)
    )
RETURN
    DIVIDE(CurrentMonth - PriorMonth, PriorMonth, 0)

// Capacity utilization percentage
Capacity Utilization % =
VAR CUConsumed = [Total CU Consumed]
VAR CUAvailable = 64 * 24 * DISTINCTCOUNT('Calendar'[Date])  -- F64 = 64 CU * hours
RETURN
    DIVIDE(CUConsumed, CUAvailable, 0)

Recommended Dashboard Pages¶

Alerting on Capacity Anomalies¶

Data Activator (Reflex) Alerts¶

{
    "trigger": {
        "type": "Reflex",
        "source": "capacity_metrics_hourly",
        "condition": {
            "measure": "ThrottlingPercent",
            "operator": "GreaterThan",
            "threshold": 10,
            "windowMinutes": 60
        },
        "actions": [
            {
                "type": "Email",
                "recipients": ["fabric-admins@contoso.com"],
                "subject": "Fabric Capacity Throttling Alert",
                "body": "Capacity {{CapacityId}} is throttling at {{ThrottlingPercent}}%"
            },
            {
                "type": "Teams",
                "channel": "Fabric-Ops",
                "message": "⚠️ Capacity throttling detected: {{ThrottlingPercent}}%"
            }
        ]
    }
}

Recommended Alert Rules¶

Comparison: FUAM vs Workspace Monitoring¶

When to Use Each¶

flowchart TD
    Q[What do I need to know?] --> A{Capacity / cost / tenant-wide?}
    A -->|Yes| FUAM[Use FUAM]
    A -->|No| B{Item-level Spark/query detail?}
    B -->|Yes| WM[Use Workspace Monitoring]
    B -->|No| C{User audit / compliance?}
    C -->|Yes| FUAM
    C -->|No| D[Check Activity Log API]

RBAC for Admin Monitoring¶

Implementing RLS on FUAM Reports¶

// Row-Level Security for cost center scoping
[CostCenterFilter] =
VAR UserEmail = USERPRINCIPALNAME()
VAR UserCostCenters =
    CALCULATETABLE(
        VALUES(CostCenterMapping[CostCenter]),
        CostCenterMapping[UserEmail] = UserEmail
    )
RETURN
    capacity_operations[CostCenter] IN UserCostCenters

Casino Implementation¶

Casino Capacity Monitoring Queries¶

// Casino real-time pipeline CU consumption
capacity_operations
| where WorkspaceName == "Casino-POC-Prod"
| where ItemType in ("Notebook", "Pipeline", "Eventstream")
| where StartTime > ago(24h)
| summarize
    TotalCUHours = round(sum(CUSeconds) / 3600.0, 2),
    OperationCount = count(),
    AvgDuration = avg(datetime_diff('second', EndTime, StartTime))
    by ItemType, ItemName
| order by TotalCUHours desc

// Detect if real-time slot telemetry is consuming disproportionate CU
capacity_operations
| where WorkspaceName == "Casino-POC-Prod"
| where ItemName has "slot_telemetry" or ItemName has "eventstream"
| where StartTime > ago(7d)
| summarize DailyCU = sum(CUSeconds) / 3600.0 by bin(StartTime, 1d)
| render columnchart with (title="Slot Telemetry CU Consumption (7d)")

Federal Agency Implementation¶

Cross-Agency Cost Allocation¶

// Cost per federal agency workspace
Agency Cost =
CALCULATE(
    [Total CU Consumed] * 0.36,
    FILTER(
        ALL(capacity_operations),
        capacity_operations[WorkspaceName] IN {
            "Federal-USDA-Prod",
            "Federal-SBA-Prod",
            "Federal-NOAA-Prod",
            "Federal-EPA-Prod",
            "Federal-DOI-Prod",
            "Federal-DOJ-Prod"
        }
    )
)

// Federal agency usage comparison
capacity_operations
| where WorkspaceName startswith "Federal-"
| where StartTime > ago(30d)
| extend Agency = extract("Federal-([A-Z]+)-", 1, WorkspaceName)
| summarize
    TotalCUHours = round(sum(CUSeconds) / 3600.0, 2),
    ItemCount = dcount(ItemId),
    UserCount = dcount(UserId)
    by Agency
| order by TotalCUHours desc

Limitations¶

References¶

• Fabric Admin Monitoring overview
• Capacity Metrics in Microsoft Fabric
• Workspace Monitoring documentation
• Data Activator alerting
• Fabric REST API - Admin