Fix 0X00001AA5: transaction manager already consistent

Quick answer

Check that the resource manager is not being double-initialized. If you see this after a crash or failover, the database is consistent — no fix needed. If it persists during normal operation, restart the MSDTC service or the SQL Server instance.

Why you're seeing this

0X00001AA5 is a status code from the Kernel Transaction Manager (KTM) in Windows. It's not a real error — it's a status message saying "I already handled that, stop asking." The transactional resource manager has completed its recovery pass and determined that the transaction log is consistent. No rollback or redo is required.

You'll typically hit this in two scenarios. First, after an unclean shutdown of SQL Server (or any KTM-aware application) — the recovery manager runs, finds everything clean, and logs this status. Second, during a replication failover where the secondary node tries to start recovery but the primary already finished it. In both cases, the system is telling you it's fine, but the logging level makes it look like a problem.

What's actually happening here is the recovery manager checks the transaction log for any in-flight transactions that need to be rolled forward or back. If the log is empty or all transactions were committed, it returns 0X00001AA5 instead of 0 (success). The distinction matters internally — 0 would mean "I did work," while this code means "no work needed."

How to fix it

Check the event log context. Open Event Viewer, navigate to Windows Logs > Application. Look for the error around the same timestamp. If it's paired with an informational message like "Recovery completed successfully," you're done. The database is consistent.
```
Get-EventLog -LogName Application -InstanceId 0X00001AA5 -Newest 10 | Format-Table TimeGenerated, Message -AutoSize
```
Restart MSDTC. If the error keeps appearing in a loop, the Distributed Transaction Coordinator may be stuck in a state where it's re-running recovery. Restart it from an elevated command prompt:
```
net stop msdtc && net start msdtc
```
This forces the resource manager to release any lingering handles. On SQL Server 2019 and older, I've seen this clear the spam in under 10 seconds.
Restart SQL Server. If restarting MSDTC doesn't stop the error, restart the SQL Server service. The transaction manager inside SQL Server may have a cached recovery state that's not clearing. This is rare but happens when the error appears in the SQL Server error log itself.
```
Restart-Service MSSQLSERVER
```
Replace MSSQLSERVER with your instance name if it's a named instance.
Verify database consistency. Run DBCC CHECKDB on the affected database. The error should not indicate corruption, but if you're paranoid (or your DBA demands proof), do a consistency check.
```
DBCC CHECKDB('YourDatabaseName') WITH NO_INFOMSGS, ALL_ERRORMSGS;
```
If it returns clean and you still see the error, it's definitely just a status message.

Alternative fixes if the main ones fail

Disable and re-enable the resource manager. In SQL Server, run:
```
EXEC sp_configure 'show advanced options', 1; RECONFIGURE; EXEC sp_configure 'remote proc trans', 0; RECONFIGURE;
```
Then re-enable it. This resets the transaction manager registration without a full restart.

Kill orphaned transaction processes. Use

SELECT session_id, transaction_id, open_transaction_count FROM sys.dm_exec_sessions WHERE open_transaction_count > 0

to find any stuck transactions. Kill them with KILL [session_id].

Check for replication issues. If this happens during log shipping or replication, verify the secondary is not trying to start a new recovery while the primary still holds locks. Run
```
SELECT * FROM sys.dm_tran_database_transactions WHERE database_id = DB_ID('YourDatabaseName')
```
to see active transactions.

Prevention tip

This error is benign, but if you're seeing it in your monitoring system and it's causing false alerts, suppress it. In SQL Server Agent alerts, add a filter on error severity. Set the alert to trigger only on severity 16 and above — 0X00001AA5 is severity 0. In your monitoring tool, add a rule to ignore this specific error code. The root cause is usually a crash, so focus on preventing unplanned restarts: enable page file on the database drives, set SQL Server max memory correctly, and keep Windows patched. The error itself is a side effect, not the problem.