Merge pull request #577 from KelvinTegelaar/dev

[pull] dev from KelvinTegelaar:dev

Author: pull[bot]

.github/workflows/dev_cippwubam.yml

@@ -0,0 +1,32 @@
+# Docs for the Azure Web Apps Deploy action: https://github.com/azure/functions-action
+# More GitHub Actions for Azure: https://github.com/Azure/actions
+
+name: Build and deploy Powershell project to Azure Function App - cippwubam
+
+on:
+  push:
+    branches:
+      - dev
+  workflow_dispatch:
+
+env:
+  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.' # set this to the path to your web app project, defaults to the repository root
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: 'Checkout GitHub Action'
+        uses: actions/checkout@v4
+      
+      - name: 'Run Azure Functions Action'
+        uses: Azure/functions-action@v1
+        id: fa
+        with:
+          app-name: 'cippwubam'
+          slot-name: 'Production'
+          package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
+          publish-profile: ${{ secrets.AZUREAPPSERVICE_PUBLISHPROFILE_1EF590059B3740EF954AFF32CF485EF0 }}
+          sku: 'flexconsumption'
+        

Modules/CIPPCore/Public/Entrypoints/Activity Triggers/Standards/Push-CIPPStandard.ps1

@@ -49,7 +49,28 @@ function Push-CIPPStandard {
             $Settings = $Item.Settings
         }
 
-        & $FunctionName -Tenant $Item.Tenant -Settings $Settings -ErrorAction Stop
+        # Prepare telemetry metadata for standard execution
+        $metadata = @{
+            Standard       = $Standard
+            Tenant         = $Tenant
+            TemplateId     = $Item.templateId
+            FunctionName   = $FunctionName
+            TriggerType    = 'Standard'
+        }
+
+        # Add template-specific metadata
+        if ($Standard -eq 'IntuneTemplate' -and $Item.Settings.TemplateList.value) {
+            $metadata['IntuneTemplateId'] = $Item.Settings.TemplateList.value
+        }
+        if ($Standard -eq 'ConditionalAccessTemplate' -and $Item.Settings.TemplateList.value) {
+            $metadata['CATemplateId'] = $Item.Settings.TemplateList.value
+        }
+
+        # Wrap the standard execution with telemetry
+        Measure-CippTask -TaskName $Standard -EventName 'CIPP.StandardCompleted' -Metadata $metadata -Script {
+            & $FunctionName -Tenant $Item.Tenant -Settings $Settings -ErrorAction Stop
+        }
+
         Write-Information "Standard $($Standard) completed for tenant $($Tenant)"
     } catch {
         Write-LogMessage -API 'Standards' -tenant $Tenant -message "Error running standard $($Standard) for tenant $($Tenant) - $($_.Exception.Message)" -sev Error -LogData (Get-CippException -Exception $_)

Modules/CIPPCore/Public/Entrypoints/HTTP Functions/New-CippCoreRequest.ps1

@@ -69,7 +69,31 @@ function New-CippCoreRequest {
                 Write-Information "Access: $Access"
                 Write-LogMessage -headers $Headers -API $Request.Params.CIPPEndpoint -message 'Accessed this API' -Sev 'Debug'
                 if ($Access) {
-                    $Response = & $FunctionName @HttpTrigger
+                    # Prepare telemetry metadata for HTTP API call
+                    $metadata = @{
+                        Endpoint     = $Request.Params.CIPPEndpoint
+                        FunctionName = $FunctionName
+                        Method       = $Request.Method
+                        TriggerType  = 'HTTP'
+                    }
+
+                    # Add tenant filter if present
+                    if ($Request.Query.TenantFilter) {
+                        $metadata['Tenant'] = $Request.Query.TenantFilter
+                    } elseif ($Request.Body.TenantFilter) {
+                        $metadata['Tenant'] = $Request.Body.TenantFilter
+                    }
+
+                    # Add user info if available
+                    if ($Request.Headers.'x-ms-client-principal-name') {
+                        $metadata['User'] = $Request.Headers.'x-ms-client-principal-name'
+                    }
+
+                    # Wrap the API call execution with telemetry
+                    $Response = Measure-CippTask -TaskName $Request.Params.CIPPEndpoint -Metadata $metadata -Script {
+                        & $FunctionName @HttpTrigger
+                    }
+
                     # Filter to only return HttpResponseContext objects
                     $HttpResponse = $Response | Where-Object { $_.PSObject.TypeNames -eq 'Microsoft.Azure.Functions.PowerShellWorker.HttpResponseContext' }
                     if ($HttpResponse) {

Modules/CIPPCore/Public/Tools/Measure-CippTask.ps1

@@ -0,0 +1,109 @@
+function Measure-CippTask {
+    <#
+    .SYNOPSIS
+        Measure and track CIPP task execution with Application Insights telemetry
+    .DESCRIPTION
+        Wraps task execution in a timer, sends custom event to Application Insights with duration and metadata
+    .PARAMETER TaskName
+        The name of the task being executed (e.g., "New-CIPPTemplateRun")
+    .PARAMETER Script
+        The scriptblock to execute and measure
+    .PARAMETER Metadata
+        Optional hashtable of metadata to include in telemetry (e.g., Command, Tenant, TaskInfo)
+    .PARAMETER EventName
+        Optional custom event name (default: "CIPP.TaskCompleted")
+    .FUNCTIONALITY
+        Internal
+    .EXAMPLE
+        Measure-CippTask -TaskName "ApplyTemplate" -Script {
+            # Task logic here
+        } -Metadata @{
+            Command = "New-CIPPTemplateRun"
+            Tenant = "contoso.onmicrosoft.com"
+        }
+    .EXAMPLE
+        Measure-CippTask -TaskName "DisableGuests" -EventName "CIPP.StandardCompleted" -Script {
+            # Standard logic here
+        } -Metadata @{
+            Standard = "DisableGuests"
+            Tenant = "contoso.onmicrosoft.com"
+        }
+    #>
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$TaskName,
+
+        [Parameter(Mandatory = $true)]
+        [scriptblock]$Script,
+
+        [Parameter(Mandatory = $false)]
+        [hashtable]$Metadata,
+
+        [Parameter(Mandatory = $false)]
+        [string]$EventName = 'CIPP.TaskCompleted'
+    )
+
+    # Initialize tracking variables
+    $sw = [System.Diagnostics.Stopwatch]::StartNew()
+    $result = $null
+    $errorOccurred = $false
+    $errorMessage = $null
+
+    try {
+        # Execute the actual task
+        $result = & $Script
+    } catch {
+        $errorOccurred = $true
+        $errorMessage = $_.Exception.Message
+        # Re-throw to preserve original error behavior
+        throw
+    } finally {
+        # Stop the timer
+        $sw.Stop()
+        $durationMs = [int]$sw.Elapsed.TotalMilliseconds
+
+        # Send telemetry if TelemetryClient is available
+        if ($global:TelemetryClient) {
+            try {
+                # Build properties dictionary for customDimensions
+                $props = New-Object 'System.Collections.Generic.Dictionary[string,string]'
+                $props['TaskName'] = $TaskName
+                $props['Success'] = (-not $errorOccurred).ToString()
+
+                if ($errorOccurred) {
+                    $props['ErrorMessage'] = $errorMessage
+                }
+
+                # Add all metadata to properties
+                if ($Metadata) {
+                    foreach ($key in $Metadata.Keys) {
+                        $value = $Metadata[$key]
+                        # Convert value to string, handling nulls
+                        if ($null -ne $value) {
+                            $props[$key] = [string]$value
+                        } else {
+                            $props[$key] = ''
+                        }
+                    }
+                }
+
+                # Metrics dictionary for customMeasurements
+                $metrics = New-Object 'System.Collections.Generic.Dictionary[string,double]'
+                $metrics['DurationMs'] = [double]$durationMs
+
+                # Send custom event to Application Insights
+                $global:TelemetryClient.TrackEvent($EventName, $props, $metrics)
+                $global:TelemetryClient.Flush()
+
+                Write-Verbose "Telemetry sent for task '$TaskName' to event '$EventName' (${durationMs}ms)"
+            } catch {
+                Write-Warning "Failed to send telemetry for task '${TaskName}': $($_.Exception.Message)"
+            }
+        } else {
+            Write-Verbose "TelemetryClient not initialized, skipping telemetry for task '$TaskName'"
+        }
+    }
+
+    return $result
+}

Modules/CippEntrypoints/CippEntrypoints.psm1

@@ -294,9 +294,52 @@ function Receive-CippActivityTrigger {
 
         if ($Item.FunctionName) {
             $FunctionName = 'Push-{0}' -f $Item.FunctionName
+            
+            # Prepare telemetry metadata
+            $taskName = if ($Item.Command) { $Item.Command } else { $FunctionName }
+            $metadata = @{
+                Command      = if ($Item.Command) { $Item.Command } else { $FunctionName }
+                FunctionName = $FunctionName
+            }
+            
+            # Add tenant information if available
+            if ($Item.TaskInfo) {
+                if ($Item.TaskInfo.Tenant) {
+                    $metadata['Tenant'] = $Item.TaskInfo.Tenant
+                }
+                if ($Item.TaskInfo.Name) {
+                    $metadata['JobName'] = $Item.TaskInfo.Name
+                }
+                if ($Item.TaskInfo.Recurrence) {
+                    $metadata['Recurrence'] = $Item.TaskInfo.Recurrence
+                }
+            }
+            
+            # Add tenant from other common fields
+            if (-not $metadata['Tenant']) {
+                if ($Item.TenantFilter) {
+                    $metadata['Tenant'] = $Item.TenantFilter
+                } elseif ($Item.Tenant) {
+                    $metadata['Tenant'] = $Item.Tenant
+                }
+            }
+            
+            # Add queue information
+            if ($Item.QueueId) {
+                $metadata['QueueId'] = $Item.QueueId
+            }
+            if ($Item.QueueName) {
+                $metadata['QueueName'] = $Item.QueueName
+            }
+            
             try {
                 Write-Warning "Activity starting Function: $FunctionName."
-                $Output = Invoke-Command -ScriptBlock { & $FunctionName -Item $Item }
+                
+                # Wrap the function execution with telemetry
+                $Output = Measure-CippTask -TaskName $taskName -Metadata $metadata -Script {
+                    Invoke-Command -ScriptBlock { & $FunctionName -Item $Item }
+                }
+                
                 Write-Warning "Activity completed Function: $FunctionName."
                 if ($TaskStatus) {
                     $QueueTask.Status = 'Completed'
@@ -389,7 +432,31 @@ function Receive-CIPPTimerTrigger {
                 $Parameters = $Function.Parameters | ConvertTo-Json | ConvertFrom-Json -AsHashtable
             }
 
-            $Results = Invoke-Command -ScriptBlock { & $Function.Command @Parameters }
+            # Prepare telemetry metadata
+            $metadata = @{
+                Command    = $Function.Command
+                Cron       = $Function.Cron
+                FunctionId = $Function.Id
+                TriggerType = 'Timer'
+            }
+            
+            # Add parameters if available
+            if ($Parameters.Count -gt 0) {
+                $metadata['ParameterCount'] = $Parameters.Count
+                # Add specific known parameters
+                if ($Parameters.Tenant) {
+                    $metadata['Tenant'] = $Parameters.Tenant
+                }
+                if ($Parameters.TenantFilter) {
+                    $metadata['Tenant'] = $Parameters.TenantFilter
+                }
+            }
+
+            # Wrap the timer function execution with telemetry
+            $Results = Measure-CippTask -TaskName $Function.Command -Metadata $metadata -Script {
+                Invoke-Command -ScriptBlock { & $Function.Command @Parameters }
+            }
+            
             if ($Results -match '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$') {
                 $FunctionStatus.OrchestratorId = $Results -join ','
                 $Status = 'Started'

Modules/CippExtensions/Public/NinjaOne/Invoke-NinjaOneTenantSync.ps1

@@ -1654,7 +1654,7 @@ function Invoke-NinjaOneTenantSync {
             $ParsedAdmins = [PSCustomObject]@{}
 
             $AdminUsers | Select-Object displayname, userPrincipalName -Unique | ForEach-Object {
-                $ParsedAdmins | Add-Member -NotePropertyName $_.displayname -NotePropertyValue $_.userPrincipalName
+                $ParsedAdmins | Add-Member -NotePropertyName $_.displayname -NotePropertyValue $_.userPrincipalName -Force
             }
 
             $TenantDetailsItems = [PSCustomObject]@{

Shared/AppInsights/Microsoft.ApplicationInsights.dll

@@ -1,5 +1,42 @@
 Write-Information '#### CIPP-API Start ####'
 
+# Load Application Insights SDK for telemetry
+Set-Location -Path $PSScriptRoot
+try {
+    $AppInsightsDllPath = Join-Path $PSScriptRoot 'Shared\AppInsights\Microsoft.ApplicationInsights.dll'
+    if (Test-Path $AppInsightsDllPath) {
+        [Reflection.Assembly]::LoadFile($AppInsightsDllPath) | Out-Null
+        Write-Information 'Application Insights SDK loaded successfully'
+    } else {
+        Write-Warning "Application Insights DLL not found at: $AppInsightsDllPath"
+    }
+} catch {
+    Write-Warning "Failed to load Application Insights SDK: $($_.Exception.Message)"
+}
+
+# Initialize global TelemetryClient
+if (-not $global:TelemetryClient) {
+    try {
+        $connectionString = $env:APPLICATIONINSIGHTS_CONNECTION_STRING
+        if ($connectionString) {
+            # Use connection string (preferred method)
+            $config = [Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration]::CreateDefault()
+            $config.ConnectionString = $connectionString
+            $global:TelemetryClient = [Microsoft.ApplicationInsights.TelemetryClient]::new($config)
+            Write-Information 'TelemetryClient initialized with connection string'
+        } elseif ($env:APPINSIGHTS_INSTRUMENTATIONKEY) {
+            # Fall back to instrumentation key
+            $global:TelemetryClient = [Microsoft.ApplicationInsights.TelemetryClient]::new()
+            $global:TelemetryClient.InstrumentationKey = $env:APPINSIGHTS_INSTRUMENTATIONKEY
+            Write-Information 'TelemetryClient initialized with instrumentation key'
+        } else {
+            Write-Warning 'No Application Insights connection string or instrumentation key found'
+        }
+    } catch {
+        Write-Warning "Failed to initialize TelemetryClient: $($_.Exception.Message)"
+    }
+}
+
 # Import modules
 @('CIPPCore', 'CippExtensions', 'Az.KeyVault', 'Az.Accounts', 'AzBobbyTables') | ForEach-Object {
     try {