DiagnosticTraceRecords.cs source code in C# .NET

                        
Code:
                         / WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / TransactionBridge / Microsoft / Transactions / Wsat / Protocol / DiagnosticTraceRecords.cs / 1 / DiagnosticTraceRecords.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------

// This file implements the trace records published by WS-AT 

using System; 
using System.ServiceModel.Channels; 
using System.Diagnostics;
using System.Runtime.Serialization; 
using System.ServiceModel;
using System.Xml;
using Microsoft.Transactions.Bridge;
using Microsoft.Transactions.Wsat.Messaging; 
using System.ServiceModel.Diagnostics;
using DiagnosticUtility = Microsoft.Transactions.Bridge.DiagnosticUtility; 
 
namespace Microsoft.Transactions.Wsat.Protocol
{ 
    //
    // Common definitions
    //
    enum TransactionOutcome 
    {
        Committed, 
        Aborted, 
        InDoubt
    } 

    //
    // WS-AT protocol service trace records
    // 

    static class TransactionTraceRecord 
    { 
        public static void SerializeRecord(XmlWriter xmlWriter, object o)
        { 
            DataContractSerializer serializer = new DataContractSerializer(o.GetType());
            serializer.WriteObject(xmlWriter, o);
        }
    } 

    // Critical 
    static class UnhandledStateMachineExceptionRecord 
    {
        public static void TraceAndLog( 
            Guid enlistmentId,
            string transactionId,
            string stateMachineName,
            string currentState, 
            StateMachineHistory history, /* optional */
            Exception e) 
        { 
            DiagnosticUtility.EventLog.LogEvent(
                TraceEventType.Critical, 
                EventLogCategory.StateMachine,
                EventLogEventId.UnhandledStateMachineExceptionRecordDescription,
                transactionId,
                stateMachineName, 
                currentState,
                history == null ? string.Empty : history.ToString(), 
                enlistmentId.ToString(), 
                e.ToString());
        } 
    }

    static class FatalUnexpectedStateMachineEventRecord
    { 
        public static void TraceAndLog(
            Guid enlistmentId, 
            string transactionId, 
            string stateMachineName,
            string currentState, 
            StateMachineHistory history, /* optional */
            string eventName,
            string eventDetails /* optional */
            ) 
        {
            DiagnosticUtility.EventLog.LogEvent( 
                TraceEventType.Critical, 
                EventLogCategory.StateMachine,
                EventLogEventId.FatalUnexpectedStateMachineEvent, 
                transactionId,
                stateMachineName,
                currentState,
                history == null ? string.Empty : history.ToString(), 
                eventName,
                string.IsNullOrEmpty(eventDetails) ? string.Empty : eventDetails); 
        } 
    }
 
    static class ParticipantRecoveryLogEntryCorruptRecord
    {
        public static void TraceAndLog(
            Guid localTransactionId, 
            string transactionId,
            byte[] recoveryData /* optional */, 
            Exception e 
            )
        { 
            using (Activity.CreateActivity(localTransactionId))
            {
                DiagnosticUtility.EventLog.LogEvent(
                    TraceEventType.Critical, 
                    EventLogCategory.StateMachine,
                    EventLogEventId.ParticipantRecoveryLogEntryCorrupt, 
                    transactionId, 
                    Convert.ToBase64String(recoveryData),
                    e.ToString()); 
            }
        }
    }
 
    static class CoordinatorRecoveryLogEntryCorruptRecord
    { 
        public static void TraceAndLog( 
            Guid localTransactionId,
            string transactionId, 
            byte[] recoveryData /* optional */,
            Exception e
            )
        { 
            using (Activity.CreateActivity(localTransactionId))
            { 
                DiagnosticUtility.EventLog.LogEvent( 
                    TraceEventType.Critical,
                    EventLogCategory.StateMachine, 
                    EventLogEventId.CoordinatorRecoveryLogEntryCorrupt,
                    transactionId,
                    Convert.ToBase64String(recoveryData),
                    e.ToString()); 
            }
        } 
    } 

    static class TransactionBridgeRecoveryFailureRecord 
    {
        public static void TraceAndLog(Exception e)
        {
            DiagnosticUtility.EventLog.LogEvent( 
                TraceEventType.Critical,
                EventLogCategory.Wsat, 
                EventLogEventId.TransactionBridgeRecoveryFailure, 
                e.ToString());
        } 
    }

    // Error
    static class CoordinatorRecoveryLogEntryCreationFailureRecord 
    {
        public static void TraceAndLog(Guid enlistmentId, 
                                       string transactionId, 
                                       string reason,
                                       Exception e) 
        {
            using (Activity.CreateActivity(enlistmentId))
            {
                DiagnosticUtility.EventLog.LogEvent( 
                    TraceEventType.Error,
                    EventLogCategory.StateMachine, 
                    EventLogEventId.CoordinatorRecoveryLogEntryCreationFailure, 
                    transactionId,
                    reason, 
                    e.ToString());
            }
        }
    } 

    static class ParticipantRecoveryLogEntryCreationFailureRecord 
    { 
        public static void TraceAndLog(Guid enlistmentId,
                                       string transactionId, 
                                       string reason,
                                       Exception e)
        {
            using (Activity.CreateActivity(enlistmentId)) 
            {
                DiagnosticUtility.EventLog.LogEvent( 
                    TraceEventType.Error, 
                    EventLogCategory.StateMachine,
                    EventLogEventId.ParticipantRecoveryLogEntryCreationFailure, 
                    transactionId,
                    enlistmentId.ToString(),
                    reason,
                    e.ToString()); 
            }
        } 
    } 

    static class ProtocolInitializationFailureRecord 
    {
        public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
        {
            using (Activity.CreateActivity(protocolId)) 
            {
                DiagnosticUtility.EventLog.LogEvent( 
                    TraceEventType.Error, 
                    EventLogCategory.Wsat,
                    EventLogEventId.ProtocolInitializationFailure, 
                    protocolId.ToString(),
                    protocolName,
                    e.ToString());
            } 
        }
    } 
 
    static class ProtocolStartFailureRecord
    { 
        public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
        {
            using (Activity.CreateActivity(protocolId))
            { 
                DiagnosticUtility.EventLog.LogEvent(
                    TraceEventType.Error, 
                    EventLogCategory.Wsat, 
                    EventLogEventId.ProtocolStartFailure,
                    protocolId.ToString(), 
                    protocolName,
                    e.ToString());
            }
        } 
    }
 
    static class ProtocolRecoveryCompleteFailureRecord 
    {
        public static void TraceAndLog(Guid protocolId, string protocolName, Exception e) 
        {
            using (Activity.CreateActivity(protocolId))
            {
                DiagnosticUtility.EventLog.LogEvent( 
                    TraceEventType.Error,
                    EventLogCategory.Wsat, 
                    EventLogEventId.ProtocolRecoveryCompleteFailure, 
                    protocolId.ToString(),
                    protocolName, 
                    e.ToString());
            }
        }
    } 

    static class ProtocolRecoveryBeginningFailureRecord 
    { 
        public static void TraceAndLog(Guid protocolId, string protocolName, Exception e)
        { 
            using (Activity.CreateActivity(protocolId))
            {
                DiagnosticUtility.EventLog.LogEvent(
                    TraceEventType.Error, 
                    EventLogCategory.Wsat,
                    EventLogEventId.ProtocolRecoveryBeginningFailure, 
                    protocolId.ToString(), 
                    protocolName,
                    e.ToString()); 
            }
        }
    }
 
    static class ProtocolStopFailureRecord
    { 
        public static void TraceAndLog(Guid protocolId, string protocolName, Exception e) 
        {
            using (Activity.CreateActivity(protocolId)) 
            {
                DiagnosticUtility.EventLog.LogEvent(
                    TraceEventType.Error,
                    EventLogCategory.Wsat, 
                    EventLogEventId.ProtocolStopFailure,
                    protocolId.ToString(), 
                    protocolName, 
                    e.ToString());
            } 
        }
    }

    // Warning 
    static class NonFatalUnexpectedStateMachineEventRecord
    { 
        public static void TraceAndLog( 
            Guid enlistmentId,
            string transactionId, 
            string stateMachine,
            string currentState,
            StateMachineHistory history, /* optional */
            string eventName, 
            string eventDetails /* optional */
            ) 
        { 
            using (Activity.CreateActivity(enlistmentId))
            { 
                DiagnosticUtility.EventLog.LogEvent(
                    TraceEventType.Warning,
                    EventLogCategory.StateMachine,
                    EventLogEventId.NonFatalUnexpectedStateMachineEvent, 
                    transactionId,
                    stateMachine, 
                    currentState, 
                    history == null ? string.Empty : history.ToString(),
                    eventName, 
                    string.IsNullOrEmpty(eventDetails) ? string.Empty : eventDetails);
            }
        }
    } 

    static class PerformanceCounterInitializationFailureRecord 
    { 
        public static void TraceAndLog(Guid protocolId, string counterName, Exception e)
        { 
            using (Activity.CreateActivity(protocolId))
            {
                DiagnosticUtility.EventLog.LogEvent(
                    TraceEventType.Warning, 
                    EventLogCategory.PerformanceCounter,
                    EventLogEventId.PerformanceCounterInitializationFailure, 
                    counterName, 
                    e.ToString());
            } 
        }
    }

    static class CreateTransactionFailureRecord 
    {
        public static bool ShouldTrace 
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; }
        } 

        public static void Trace(Guid enlistmentId, string reason)
        {
            ReasonRecordSchema record = new ReasonRecordSchema(reason); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, 
                                       TraceCode.CreateTransactionFailure, 
                                       SR.GetString(SR.CreateTransactionFailure),
                                       record, null, enlistmentId, null); 
        }
    }

    static class EnlistTransactionFailureRecord 
    {
        public static bool ShouldTrace 
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; }
        } 

        public static void Trace(Guid enlistmentId, CoordinationContext context, string reason)
        {
            ReasonRecordSchema record = new ReasonRecordSchema(reason); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, 
                                       TraceCode.EnlistTransactionFailure, 
                                       SR.GetString(SR.EnlistTransactionFailure),
                                       record, null, enlistmentId, null); 
        }
    }

    static class RegisterParticipantFailureRecord 
    {
        public static bool ShouldTrace 
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; }
        } 

        public static void Trace(
            Guid enlistmentId,
            string transactionId, 
            ControlProtocol protocol,
            EndpointAddress protocolService, 
            string reason, 
            ProtocolVersion protocolVersion
            ) 
        {
            RegisterFailureRecordSchema record = RegisterFailureRecordSchema.Instance(
                transactionId, protocol, protocolService, reason, protocolVersion);
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
                                       GetCode(protocolVersion), 
                                       SR.GetString(SR.RegisterParticipantFailure), 
                                       record, null, enlistmentId, null);
        } 

        static Type type = typeof(RegisterParticipantFailureRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion)
        { 
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
 
            switch (protocolVersion) 
            {
                case ProtocolVersion.Version10 : 
                    return TraceCode.RegisterParticipantFailure;

                case ProtocolVersion.Version11 :
                    return TraceCode.RegisterParticipantFailure11; 

                default: 
                    return 0; // inaccessible path because we have asserted the protocol version 
            }
        } 
    }

    static class VolatileOutcomeTimeoutRecord
    { 
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; } 
        }
 
        public static void Trace(
            Guid enlistmentId,
            string transactionId,
            TransactionOutcome outcome, 
            TimeSpan timeout
            ) 
        { 
            EnlistmentTimeoutRecordSchema record = new EnlistmentTimeoutRecordSchema(
                transactionId, enlistmentId, outcome, timeout); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
                                       TraceCode.VolatileOutcomeTimeout,
                                       SR.GetString(SR.VolatileOutcomeTimeout), 
                                       record, null, enlistmentId, null);
        } 
    } 

    static class VolatileParticipantInDoubtRecord 
    {
        public static bool ShouldTrace
        {
            get { return DiagnosticUtility.ShouldTraceWarning; } 
        }
 
        public static void Trace(Guid enlistmentId, 
                                 EndpointAddress replyTo /* optional */,
                                 ProtocolVersion protocolVersion 
            )
        {
            VolatileEnlistmentInDoubtRecordSchema record = VolatileEnlistmentInDoubtRecordSchema.Instance(
                enlistmentId, replyTo, protocolVersion); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, 
                                       GetCode(protocolVersion), 
                                       SR.GetString(SR.VolatileParticipantInDoubt),
                                       record, null, enlistmentId, null); 
        }

        static Type type = typeof(VolatileParticipantInDoubtRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion) 
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode"); 
 
            switch (protocolVersion)
            { 
                case ProtocolVersion.Version10 :
                    return TraceCode.VolatileParticipantInDoubt;

                case ProtocolVersion.Version11 : 
                    return TraceCode.VolatileParticipantInDoubt11;
 
                default: 
                    return 0; // inaccessible path because we have asserted the protocol version
            } 
        }
    }

    static class DurableParticipantReplayWhilePreparingRecord 
    {
        public static bool ShouldTrace 
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; }
        } 

        public static void Trace(Guid enlistmentId, string transactionId)
        {
            EnlistmentRecordSchema record = new EnlistmentRecordSchema(transactionId, enlistmentId); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, 
                                       TraceCode.DurableParticipantReplayWhilePreparing, 
                                       SR.GetString(SR.DurableParticipantReplayWhilePreparing),
                                       record, null, enlistmentId, null); 
        }
    }

    static class RegistrationCoordinatorFaultedRecord 
    {
        public static bool ShouldTrace 
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; }
        } 

        public static void Trace(
            Guid enlistmentId,
            CoordinationContext context, 
            ControlProtocol protocol,
            MessageFault fault 
            ) 
        {
            RegistrationCoordinatorFaultedSchema record = new RegistrationCoordinatorFaultedSchema( 
                context, protocol, fault);

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
                                       TraceCode.RegistrationCoordinatorFaulted, 
                                       SR.GetString(SR.RegistrationCoordinatorFaulted),
                                       record, null, enlistmentId, null); 
        } 
    }
 
    static class RegistrationCoordinatorFailedRecord
    {
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; }
        } 
 
        public static void Trace(
            Guid enlistmentId, 
            CoordinationContext context,
            ControlProtocol protocol,
            Exception e
            ) 
        {
            RegistrationCoordinatorFailedSchema record = new RegistrationCoordinatorFailedSchema( 
                context, protocol); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning, 
                                       TraceCode.RegistrationCoordinatorFailed,
                                       SR.GetString(SR.RegistrationCoordinatorFailed),
                                       record, null, enlistmentId, null);
        } 
    }
 
    static class RegistrationCoordinatorResponseInvalidMetadataRecord 
    {
        public static bool ShouldTrace 
        {
            get { return DiagnosticUtility.ShouldTraceWarning; }
        }
 
        public static void Trace(
            Guid enlistmentId, 
            CoordinationContext context, 
            ControlProtocol protocol,
            EndpointAddress coordinatorService, 
            Exception e /* optional */,
            ProtocolVersion protocolVersion
            )
        { 
            RegistrationCoordinatorResponseInvalidMetadataSchema record = RegistrationCoordinatorResponseInvalidMetadataSchema.Instance(
                context, protocol, coordinatorService, protocolVersion); 
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
                                       GetCode(protocolVersion), 
                                       SR.GetString(SR.RegistrationCoordinatorResponseInvalidMetadata),
                                       record, e, enlistmentId, null);
        }
 
        static Type type = typeof(RegistrationCoordinatorResponseInvalidMetadataRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion) 
        { 
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
 
            switch (protocolVersion)
            {
                case ProtocolVersion.Version10 :
                    return TraceCode.RegistrationCoordinatorResponseInvalidMetadata; 

                case ProtocolVersion.Version11 : 
                    return TraceCode.RegistrationCoordinatorResponseInvalidMetadata11; 

                default: 
                    return 0; // inaccessible path because we have asserted the protocol version
            }
        }
    } 

    static class RecoveredCoordinatorInvalidMetadataRecord 
    { 
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; }
        }

        public static void Trace( 
            Guid enlistmentId,
            string transactionId, 
            EndpointAddress coordinatorService, 
            ProtocolVersion protocolVersion
            ) 
        {
            RecoverCoordinatorRecordSchema record = RecoverCoordinatorRecordSchema.Instance(
                transactionId, coordinatorService, protocolVersion);
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
                                       GetCode(protocolVersion), 
                                       SR.GetString(SR.RecoveredCoordinatorInvalidMetadata), 
                                       record, null, enlistmentId, null);
        } 

        static Type type = typeof(RecoveredCoordinatorInvalidMetadataRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion)
        { 
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
 
            switch (protocolVersion) 
            {
                case ProtocolVersion.Version10 : 
                    return TraceCode.RecoveredCoordinatorInvalidMetadata;

                case ProtocolVersion.Version11 :
                    return TraceCode.RecoveredCoordinatorInvalidMetadata11; 

                default: 
                    return 0; // inaccessible path because we have asserted the protocol version 
            }
        } 
    }

    static class RecoveredParticipantInvalidMetadataRecord
    { 
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceWarning; } 
        }
 
        public static void Trace(
            Guid enlistmentId,
            string transactionId,
            EndpointAddress participantService, 
            ProtocolVersion protocolVersion
            ) 
        { 
            RecoverParticipantRecordSchema record = RecoverParticipantRecordSchema.Instance(
                transactionId, enlistmentId, participantService, protocolVersion); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Warning,
                                       GetCode(protocolVersion),
                                       SR.GetString(SR.RecoveredParticipantInvalidMetadata), 
                                       record, null, enlistmentId, null);
        } 
 
        static Type type = typeof(RecoveredParticipantInvalidMetadataRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion) 
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");

            switch (protocolVersion) 
            {
                case ProtocolVersion.Version10 : 
                    return TraceCode.RecoveredParticipantInvalidMetadata; 

                case ProtocolVersion.Version11 : 
                    return TraceCode.RecoveredParticipantInvalidMetadata11;

                default:
                    return 0; // inaccessible path because we have asserted the protocol version 
            }
        } 
    } 

    // Information 
    static class EnlistTransactionRecord
    {
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceInformation; }
        } 
 
        public static void Trace(Guid enlistmentId, CoordinationContext context)
        { 
            CoordinationContextRecordSchema record = new CoordinationContextRecordSchema(context);

            if (DiagnosticUtility.ShouldTraceInformation)
            { 
                DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                           TraceCode.EnlistTransaction, 
                                           SR.GetString(SR.EnlistTransaction), 
                                           record, null, enlistmentId, null);
            } 
        }
    }

    static class RegisterCoordinatorRecord 
    {
        public static bool ShouldTrace 
        { 
            get { return DiagnosticUtility.ShouldTraceInformation; }
        } 

        public static void Trace(
            Guid enlistmentId,
            CoordinationContext context, 
            ControlProtocol protocol,
            EndpointAddress coordinatorService, 
            ProtocolVersion protocolVersion 
            )
        { 
            RegisterCoordinatorRecordSchema record = RegisterCoordinatorRecordSchema.Instance(
                context, protocol, coordinatorService, protocolVersion);

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, 
                                       GetCode(protocolVersion),
                                       SR.GetString(SR.RegisterCoordinator), 
                                       record, null, enlistmentId, null); 
        }
 
        static Type type = typeof(RegisterCoordinatorRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion)
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode"); 

            switch (protocolVersion) 
            { 
                case ProtocolVersion.Version10 :
                    return TraceCode.RegisterCoordinator; 

                case ProtocolVersion.Version11 :
                    return TraceCode.RegisterCoordinator11;
 
                default:
                    return 0; // inaccessible path because we have asserted the protocol version 
            } 
        }
    } 

    static class RegisterParticipantRecord
    {
        public static bool ShouldTrace 
        {
            get { return DiagnosticUtility.ShouldTraceInformation; } 
        } 

        public static void Trace( 
            Guid enlistmentId,
            string transactionId,
            ControlProtocol protocol,
            EndpointAddress participantService, 
            ProtocolVersion protocolVersion
            ) 
        { 
            RegisterParticipantRecordSchema record = RegisterParticipantRecordSchema.Instance(
                transactionId, enlistmentId, protocol, participantService, protocolVersion); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       GetCode(protocolVersion),
                                       SR.GetString(SR.RegisterParticipant), 
                                       record, null, enlistmentId, null);
        } 
 
        static Type type = typeof(RegisterParticipantRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion) 
        {
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");

            switch (protocolVersion) 
            {
                case ProtocolVersion.Version10 : 
                    return TraceCode.RegisterParticipant; 

                case ProtocolVersion.Version11 : 
                    return TraceCode.RegisterParticipant11;

                default:
                    return 0; // inaccessible path because we have asserted the protocol version 
            }
        } 
    } 

    static class ProtocolInitializedRecord 
    {
        public static bool ShouldTrace
        {
            get { return DiagnosticUtility.ShouldTraceInformation; } 
        }
 
        public static void Trace(Guid protocolId, string protocolName) 
        {
            ProtocolServiceRecordSchema record = new ProtocolServiceRecordSchema(protocolName, protocolId); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       TraceCode.ProtocolInitialized,
                                       SR.GetString(SR.ProtocolInitialized), 
                                       record, null, protocolId, null);
        } 
    } 

    static class ProtocolStartedRecord 
    {
        public static bool ShouldTrace
        {
            get { return DiagnosticUtility.ShouldTraceInformation; } 
        }
 
        public static void Trace(Guid protocolId, string protocolName) 
        {
            ProtocolServiceRecordSchema record = new ProtocolServiceRecordSchema(protocolName, protocolId); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       TraceCode.ProtocolStarted,
                                       SR.GetString(SR.ProtocolStarted), 
                                       record, null, protocolId, null);
        } 
    } 

    static class ProtocolRecoveryCompleteRecord 
    {
        public static void TraceAndLog(Guid protocolId, string protocolName)
        {
            using (Activity.CreateActivity(protocolId)) 
            {
                DiagnosticUtility.EventLog.LogEvent( 
                    TraceEventType.Information, 
                    EventLogCategory.Wsat,
                    EventLogEventId.ProtocolRecoveryComplete, 
                    protocolId.ToString(),
                    protocolName);
            }
        } 
    }
 
    static class ProtocolStoppedRecord 
    {
        public static void TraceAndLog(Guid protocolId, string protocolName) 
        {
            using (Activity.CreateActivity(protocolId))
            {
                DiagnosticUtility.EventLog.LogEvent( 
                    TraceEventType.Information,
                    EventLogCategory.Wsat, 
                    EventLogEventId.ProtocolStopped, 
                    protocolId.ToString(),
                    protocolName); 
            }
        }
    }
 
    static class PrepareMessageRetryRecord
    { 
        public static bool ShouldTrace 
        {
            get { return DiagnosticUtility.ShouldTraceInformation; } 
        }

        public static void Trace(Guid enlistmentId, string transactionId, int count)
        { 
            ParticipantRetryMessageRecordSchema record = new ParticipantRetryMessageRecordSchema(
                transactionId, enlistmentId, count); 
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       TraceCode.PrepareMessageRetry, 
                                       SR.GetString(SR.PrepareMessageRetry),
                                       record, null, enlistmentId, null);
        }
    } 

    static class CommitMessageRetryRecord 
    { 
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceInformation; }
        }

        public static void Trace(Guid enlistmentId, string transactionId, int count) 
        {
            ParticipantRetryMessageRecordSchema record = new ParticipantRetryMessageRecordSchema( 
                transactionId, enlistmentId, count); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information, 
                                       TraceCode.CommitMessageRetry,
                                       SR.GetString(SR.CommitMessageRetry),
                                       record, null, enlistmentId, null);
        } 
    }
 
    static class PreparedMessageRetryRecord 
    {
        public static bool ShouldTrace 
        {
            get { return DiagnosticUtility.ShouldTraceInformation; }
        }
 
        public static void Trace(Guid enlistmentId, string transactionId, int count)
        { 
            CoordinatorRetryMessageRecordSchema record = new CoordinatorRetryMessageRecordSchema( 
                transactionId, count);
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       TraceCode.PreparedMessageRetry,
                                       SR.GetString(SR.PreparedMessageRetry),
                                       record, null, enlistmentId, null); 
        }
    } 
 
    static class ReplayMessageRetryRecord
    { 
        public static bool ShouldTrace
        {
            get { return DiagnosticUtility.ShouldTraceInformation; }
        } 

        public static void Trace(Guid enlistmentId, string transactionId, int count) 
        { 
            CoordinatorRetryMessageRecordSchema record = new CoordinatorRetryMessageRecordSchema(
                transactionId, count); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       TraceCode.ReplayMessageRetry,
                                       SR.GetString(SR.ReplayMessageRetry), 
                                       record, null, enlistmentId, null);
        } 
    } 

    static class ParticipantRecoveredRecord 
    {
        public static bool ShouldTrace
        {
            get { return DiagnosticUtility.ShouldTraceInformation; } 
        }
 
        public static void Trace( 
            Guid enlistmentId,
            string transactionId, 
            EndpointAddress protocolService,
            ProtocolVersion protocolVersion
            )
        { 
            RecoverParticipantRecordSchema record = RecoverParticipantRecordSchema.Instance(
                transactionId, enlistmentId, protocolService, protocolVersion); 
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       GetCode(protocolVersion), 
                                       SR.GetString(SR.ParticipantRecovered),
                                       record, null, enlistmentId, null);
        }
 
        static Type type = typeof(ParticipantRecoveredRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion) 
        { 
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
 
            switch (protocolVersion)
            {
                case ProtocolVersion.Version10 :
                    return TraceCode.ParticipantRecovered; 

                case ProtocolVersion.Version11 : 
                    return TraceCode.ParticipantRecovered11; 

                default: 
                    return 0; // inaccessible path because we have asserted the protocol version
            }
        }
    } 

    static class CoordinatorRecoveredRecord 
    { 
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceInformation; }
        }

        public static void Trace( 
            Guid enlistmentId,
            string transactionId, 
            EndpointAddress protocolService, 
            ProtocolVersion protocolVersion
            ) 
        {
            RecoverCoordinatorRecordSchema record = RecoverCoordinatorRecordSchema.Instance(
                transactionId, protocolService, protocolVersion);
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       GetCode(protocolVersion), 
                                       SR.GetString(SR.CoordinatorRecovered), 
                                       record, null, enlistmentId, null);
        } 

        static Type type = typeof(CoordinatorRecoveredRecord);
        static TraceCode GetCode(ProtocolVersion protocolVersion)
        { 
            ProtocolVersionHelper.AssertProtocolVersion(protocolVersion, type, "GetCode");
 
            switch (protocolVersion) 
            {
                case ProtocolVersion.Version10 : 
                    return TraceCode.CoordinatorRecovered;

                case ProtocolVersion.Version11 :
                    return TraceCode.CoordinatorRecovered11; 

                default: 
                    return 0; // inaccessible path because we have asserted the protocol version 
            }
        } 
    }

    static class EnlistmentIdentityCheckFailedRecord
    { 
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceInformation; } 
        }
 
        public static void Trace(Guid enlistmentId)
        {
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Information,
                                       TraceCode.EnlistmentIdentityCheckFailed, 
                                       SR.GetString(SR.EnlistmentIdentityCheckFailed),
                                       null, null, enlistmentId, null); 
        } 
    }
 
    // Verbose
    static class ParticipantStateMachineFinishedRecord
    {
        public static bool ShouldTrace 
        {
            get { return DiagnosticUtility.ShouldTraceVerbose; } 
        } 

        public static void Trace(Guid enlistmentId, string transactionId, TransactionOutcome outcome) 
        {
            ParticipantOutcomeRecordSchema record = new ParticipantOutcomeRecordSchema(
                transactionId, enlistmentId, outcome);
 
            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Verbose,
                                       TraceCode.ParticipantStateMachineFinished, 
                                       SR.GetString(SR.ParticipantStateMachineFinished), 
                                       record, null, enlistmentId, null);
        } 
    }

    static class CoordinatorStateMachineFinishedRecord
    { 
        public static bool ShouldTrace
        { 
            get { return DiagnosticUtility.ShouldTraceVerbose; } 
        }
 
        public static void Trace(Guid enlistmentId, string transactionId, TransactionOutcome outcome)
        {
            CoordinatorOutcomeRecordSchema record = new CoordinatorOutcomeRecordSchema(
                transactionId, outcome); 

            DiagnosticUtility.DiagnosticTrace.TraceEvent(TraceEventType.Verbose, 
                                       TraceCode.CoordinatorStateMachineFinished, 
                                       SR.GetString(SR.CoordinatorStateMachineFinished),
                                       record, null, enlistmentId, null); 
        }
    }

    static class ThumbPrintNotFoundRecord 
    {
        public static void TraceAndLog(string thumbPrint) 
        { 
            DiagnosticUtility.EventLog.LogEvent(
                TraceEventType.Information, 
                EventLogCategory.Wsat,
                EventLogEventId.ThumbPrintNotFound,
                thumbPrint);
        } 
    }
 
    static class ThumbPrintNotValidatedRecord 
    {
        public static void TraceAndLog(string thumbPrint) 
        {
            DiagnosticUtility.EventLog.LogEvent(
                TraceEventType.Information,
                EventLogCategory.Wsat, 
                EventLogEventId.ThumbPrintNotValidated,
                thumbPrint); 
        } 
    }
 
    static class SslNoPrivateKeyRecord
    {
        public static void TraceAndLog(string subject, string thumbPrint)
        { 
            DiagnosticUtility.EventLog.LogEvent(
                TraceEventType.Information, 
                EventLogCategory.Wsat, 
                EventLogEventId.SslNoPrivateKey,
                subject, 
                thumbPrint);
        }
    }
 
    static class SslNoAccessiblePrivateKeyRecord
    { 
        public static void TraceAndLog(string subject, string thumbPrint) 
        {
            DiagnosticUtility.EventLog.LogEvent( 
                TraceEventType.Information,
                EventLogCategory.Wsat,
                EventLogEventId.SslNoAccessiblePrivateKey,
                subject, 
                thumbPrint);
        } 
    } 

    static class MissingNecessaryKeyUsageRecord 
    {
        public static void TraceAndLog(string subject, string thumbPrint, System.Security.Cryptography.X509Certificates.X509KeyUsageFlags keyUsage)
        {
            DiagnosticUtility.EventLog.LogEvent( 
                TraceEventType.Information,
                EventLogCategory.Wsat, 
                EventLogEventId.MissingNecessaryKeyUsage, 
                subject,
                thumbPrint, 
                keyUsage.ToString());
        }
    }
 
    static class MissingNecessaryEnhancedKeyUsageRecord
    { 
        public static void TraceAndLog(string subject, string thumbPrint, string keyUsage) 
        {
            DiagnosticUtility.EventLog.LogEvent( 
                TraceEventType.Information,
                EventLogCategory.Wsat,
                EventLogEventId.MissingNecessaryEnhancedKeyUsage,
                subject, 
                thumbPrint,
                keyUsage); 
        } 
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.


                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• TCEAdapterGenerator.cs
• DataGridTemplateColumn.cs
• Sentence.cs
• ConditionCollection.cs
• MergeLocalizationDirectives.cs
• NamedElement.cs
• TypeAccessException.cs
• FullTextState.cs
• StructuredProperty.cs
• OneToOneMappingSerializer.cs
• Cloud.cs
• SizeF.cs
• CodePropertyReferenceExpression.cs
• CodeCompileUnit.cs
• ConditionalAttribute.cs
• figurelengthconverter.cs
• WebBrowserHelper.cs
• Pointer.cs
• XmlChildEnumerator.cs
• RedirectionProxy.cs
• ModuleConfigurationInfo.cs
• PieceNameHelper.cs
• MenuTracker.cs
• CompletedAsyncResult.cs
• RequestResizeEvent.cs
• WindowsGraphicsWrapper.cs
• TabItem.cs
• DataControlPagerLinkButton.cs
• DataContractAttribute.cs
• ClientRoleProvider.cs
• GuidTagList.cs
• ForwardPositionQuery.cs
• WebConfigurationManager.cs
• ILGen.cs
• FormViewInsertEventArgs.cs
• MenuBase.cs
• CultureInfo.cs
• DiscreteKeyFrames.cs
• ServiceReference.cs
• UserPreferenceChangedEventArgs.cs
• HostedController.cs
• HMAC.cs
• PingReply.cs
• XmlSchemaAnyAttribute.cs
• QilStrConcat.cs
• WorkflowCommandExtensionItem.cs
• cookieexception.cs
• StructuredTypeEmitter.cs
• ReferentialConstraint.cs
• CodeExporter.cs
• SurrogateSelector.cs
• XmlValidatingReader.cs
• RichTextBoxAutomationPeer.cs
• regiisutil.cs
• XmlNotation.cs
• DbProviderFactory.cs
• CellPartitioner.cs
• TrackingProfileCache.cs
• LeaseManager.cs
• SpellerStatusTable.cs
• String.cs
• ResourcesChangeInfo.cs
• RSAPKCS1KeyExchangeDeformatter.cs
• Stackframe.cs
• ArgIterator.cs
• CodeDOMUtility.cs
• SpeechAudioFormatInfo.cs
• IUnknownConstantAttribute.cs
• DefaultValidator.cs
• StorageMappingFragment.cs
• ResourceContainer.cs
• ConstantSlot.cs
• BindToObject.cs
• FlowDecision.cs
• IItemContainerGenerator.cs
• QueryOutputWriter.cs
• MenuTracker.cs
• NegotiateStream.cs
• IFormattable.cs
• TypeElement.cs
• SchemaHelper.cs
• AttachedPropertiesService.cs
• Cursor.cs
• FrameworkElementFactory.cs
• DataGridViewCellStyleChangedEventArgs.cs
• IndexedGlyphRun.cs
• DocumentCollection.cs
• HttpRawResponse.cs
• CodeChecksumPragma.cs
• X509SecurityTokenProvider.cs
• XamlFilter.cs
• HttpCapabilitiesBase.cs
• MinimizableAttributeTypeConverter.cs
• ClientBuildManagerCallback.cs
• GenericEnumerator.cs
• DataGridViewCellStyleContentChangedEventArgs.cs
• AttributeCollection.cs
• LocationReferenceValue.cs
• TypeConverterHelper.cs
• DecimalKeyFrameCollection.cs