ID d'événement Windows 1026 – Erreur d'application : Détection de plantage ou de blocage d'application

Commencez par examiner les détails spécifiques de l'ID d'événement 1026 pour identifier l'application défaillante et le module défaillant.

1. Ouvrez Observateur d'événements en appuyant sur Win + R, en tapant eventvwr.msc, et en appuyant sur Entrée
2. Accédez à Journaux Windows → Application
3. Filtrez pour l'ID d'événement 1026 en cliquant avec le bouton droit sur le journal Application et en sélectionnant Filtrer le journal actuel
4. Entrez 1026 dans le champ ID d'événements et cliquez sur OK
5. Double-cliquez sur l'entrée la plus récente de l'ID d'événement 1026 pour voir les détails
6. Notez le Nom de l'application défaillante, le Nom du module défaillant, et le Code d'exception
7. Vérifiez l'onglet Général pour les informations sur le chemin de l'application et l'ID de processus

Utilisez PowerShell pour interroger plusieurs entrées de l'ID d'événement 1026 pour une analyse de modèle :

Get-WinEvent -FilterHashtable @{LogName='Application'; Id=1026} -MaxEvents 50 | Select-Object TimeCreated, LevelDisplayName, @{Name='Application';Expression={($_.Message -split '\n')[0]}}

Vérifiez que l'application défaillante dispose de toutes les dépendances requises et est compatible avec la version actuelle de Windows.

1. Identifiez l'application défaillante à partir des détails de l'ID d'événement 1026
2. Vérifiez la version de l'application et comparez-la avec les matrices de compatibilité du fournisseur
3. Vérifiez les exigences du .NET Framework ou du Redistributable Visual C++ :

# Vérifiez les versions .NET installées
Get-ChildItem 'HKLM:SOFTWARE\Microsoft\NET Framework Setup\NDP' -Recurse | Get-ItemProperty -Name version -EA 0 | Where { $_.PSChildName -Match '^(?!S)\p{L}'} | Select PSChildName, version

# Vérifiez les Redistributables Visual C++
Get-WmiObject -Class Win32_Product | Where-Object {$_.Name -like "*Visual C++*"} | Select-Object Name, Version

4. Exécutez l'outil de résolution des problèmes de compatibilité des applications :

# Lancez l'outil de résolution des problèmes de compatibilité pour une application spécifique
msdt.exe -id PCWDiagnostic

5. Vérifiez les fichiers système manquants ou corrompus :

# Exécutez le vérificateur de fichiers système
sfc /scannow

# Exécutez DISM pour réparer l'image Windows
DISM /Online /Cleanup-Image /RestoreHealth

Enquêter pour savoir si des contraintes de ressources provoquent des plantages d'application en surveillant les performances du système pendant l'exécution de l'application.

1. Ouvrir Performance Monitor (perfmon.exe) et créer un ensemble de collecteurs de données personnalisé
2. Ajouter les compteurs suivants pour surveiller l'utilisation des ressources de l'application :

# Créer un ensemble de collecteurs de données de compteurs de performance
$DataCollectorSet = New-Object -ComObject Pla.DataCollectorSet
$DataCollectorSet.DisplayName = "Enquête sur le plantage de l'application"
$DataCollectorSet.Duration = 3600  # 1 heure
$DataCollectorSet.Commit("AppCrashMonitor", $null, 0x0003)

3. Surveiller les indicateurs de performance clés :
4. Processus\Octets privés (pour l'application spécifique)
5. Processus\Nombre de poignées
6. Mémoire\Mégaoctets disponibles
7. Processus\% Temps processeur
8. Vérifier le Visualiseur d'événements pour des événements supplémentaires liés autour de l'heure du plantage :

# Obtenir les événements dans les 5 minutes suivant le plantage
$CrashTime = (Get-WinEvent -FilterHashtable @{LogName='Application'; Id=1026} -MaxEvents 1).TimeCreated
$StartTime = $CrashTime.AddMinutes(-5)
$EndTime = $CrashTime.AddMinutes(5)

Get-WinEvent -FilterHashtable @{LogName='System'; StartTime=$StartTime; EndTime=$EndTime} | Where-Object {$_.LevelDisplayName -eq 'Error' -or $_.LevelDisplayName -eq 'Warning'}

5. Utiliser Process Monitor (ProcMon) pour capturer l'accès aux fichiers et au registre pendant le démarrage et le fonctionnement de l'application
6. Activer Application Verifier pour l'application problématique afin de détecter la corruption de tas :

# Activer Application Verifier (nécessite l'outil Application Verifier)
appverif.exe -enable Heaps Handles Locks -for application.exe

Activez la collecte détaillée des vidages sur incident pour recueillir plus d'informations de diagnostic sur les défaillances des applications.

1. Configurez Windows Error Reporting pour collecter des vidages sur incident complets :

# Activer la collecte locale des vidages sur incident
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps" -Name "DumpType" -Value 2 -PropertyType DWORD -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps" -Name "DumpCount" -Value 10 -PropertyType DWORD -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps" -Name "DumpFolder" -Value "C:\CrashDumps" -PropertyType String -Force

2. Créez le répertoire de vidage sur incident avec les autorisations appropriées :

# Créer le répertoire de vidage sur incident
New-Item -Path "C:\CrashDumps" -ItemType Directory -Force

# Définir les autorisations pour la collecte des vidages sur incident
icacls "C:\CrashDumps" /grant "Everyone:(OI)(CI)F"

3. Configurez les paramètres de vidage sur incident spécifiques à l'application :

# Configurer les vidages pour une application spécifique
$AppName = "problematic_app.exe"
New-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps\$AppName" -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows\Windows Error Reporting\LocalDumps\$AppName" -Name "DumpType" -Value 2 -PropertyType DWORD -Force

4. Surveillez la génération des vidages sur incident et analysez-les à l'aide d'outils de débogage :

# Surveiller le répertoire des vidages sur incident
Get-ChildItem "C:\CrashDumps" -File | Sort-Object LastWriteTime -Descending | Select-Object Name, Length, LastWriteTime

5. Activez Dr. Watson ou configurez l'analyse automatique des vidages sur incident :

# Configurer l'analyse automatique des vidages sur incident
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AeDebug" -Name "Auto" -Value "1" -PropertyType String -Force

Utilisez des outils de compatibilité avancés et des shims d'application pour résoudre les plantages persistants des applications.

1. Téléchargez et installez le Windows Assessment and Deployment Kit (ADK) pour les outils de compatibilité
2. Lancez le Compatibility Administrator depuis le menu Windows Kits
3. Créez une base de données de compatibilité personnalisée pour l'application problématique :

# Exporter la base de données de compatibilité actuelle
sdbinst.exe -q -n "Custom_App_Fixes"

# Interroger les correctifs de compatibilité existants
Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\Custom\*" | Select-Object PSChildName

4. Appliquez des correctifs de compatibilité courants tels que :
5. Désactivation de la détection de corruption de tas
6. Exceptions DEP (Data Execution Prevention)
7. Paramètres de mode de compatibilité
8. Correctifs de redirection DLL
9. Testez l'application avec les shims de compatibilité appliqués :

# Installer la base de données de compatibilité personnalisée
sdbinst.exe "C:\CustomFixes\AppFix.sdb"

# Vérifier l'installation du shim
Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AppCompatFlags\InstalledSDB\*" | Where-Object {$_.DatabaseDescription -like "*Custom*"}

6. Surveillez le comportement de l'application avec Process Monitor pendant les tests
7. Utilisez la journalisation de l'Application Compatibility Toolkit pour suivre l'efficacité des correctifs :

# Activer la journalisation de compatibilité
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\AppCompatFlags" -Name "LogLevel" -Value 4 -PropertyType DWORD -Force

# Vérifier les journaux de compatibilité
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-Application-Experience/Program-Compatibility-Assistant/Analytic'} -MaxEvents 20

8. Documentez les correctifs réussis et déployez-les sur les systèmes affectés en utilisant Group Policy ou SCCM