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

• CodeRemoveEventStatement.cs
• OLEDB_Util.cs
• NamespaceInfo.cs
• ProcessHostConfigUtils.cs
• Accessors.cs
• SQLDecimal.cs
• DataRecordInternal.cs
• SqlConnectionFactory.cs
• TemplateDefinition.cs
• BinaryMethodMessage.cs
• SystemNetworkInterface.cs
• SByte.cs
• EndOfStreamException.cs
• sqlmetadatafactory.cs
• WebPartAuthorizationEventArgs.cs
• DataKeyArray.cs
• DataGridColumn.cs
• Ops.cs
• DataGridViewRowCancelEventArgs.cs
• ListViewInsertEventArgs.cs
• TextContainerChangeEventArgs.cs
• RequestResizeEvent.cs
• SchemaImporterExtension.cs
• MarginCollapsingState.cs
• TranslateTransform3D.cs
• ExpressionBuilder.cs
• DelegatingConfigHost.cs
• DiscoveryCallbackBehavior.cs
• ByteAnimation.cs
• MonitorWrapper.cs
• CommandLibraryHelper.cs
• FirstMatchCodeGroup.cs
• SqlOuterApplyReducer.cs
• objectresult_tresulttype.cs
• EventData.cs
• DataException.cs
• CommonObjectSecurity.cs
• KeyEventArgs.cs
• IdentityReference.cs
• PointConverter.cs
• DecoderFallbackWithFailureFlag.cs
• NGCSerializationManagerAsync.cs
• WebExceptionStatus.cs
• CookielessHelper.cs
• ModulesEntry.cs
• ExtractCollection.cs
• ModuleBuilderData.cs
• SingleBodyParameterMessageFormatter.cs
• ThreadWorkerController.cs
• UniqueIdentifierService.cs
• LinqDataSourceValidationException.cs
• ConsumerConnectionPoint.cs
• SpeechAudioFormatInfo.cs
• RunInstallerAttribute.cs
• OutputCacheProfile.cs
• Main.cs
• MultiTargetingUtil.cs
• EditorBrowsableAttribute.cs
• Cell.cs
• LayoutDump.cs
• RemoteWebConfigurationHostStream.cs
• SelectorAutomationPeer.cs
• Validator.cs
• PerformanceCounterPermissionAttribute.cs
• RepeaterItemCollection.cs
• LineUtil.cs
• BitmapPalettes.cs
• _LazyAsyncResult.cs
• OrderByBuilder.cs
• DescriptionAttribute.cs
• ZipIOZip64EndOfCentralDirectoryBlock.cs
• DescendantBaseQuery.cs
• FixedBufferAttribute.cs
• TreeView.cs
• LinkArea.cs
• ArgIterator.cs
• PeerMessageDispatcher.cs
• MasterPageParser.cs
• CompositeControl.cs
• StatusBarAutomationPeer.cs
• GrammarBuilderBase.cs
• ClientConfigurationHost.cs
• RequestSecurityTokenResponse.cs
• WebResourceUtil.cs
• DeflateEmulationStream.cs
• CategoryList.cs
• PriorityRange.cs
• ExpressionBuilder.cs
• SimpleType.cs
• ConfigurationException.cs
• XmlImplementation.cs
• XmlElementList.cs
• Point.cs
• WSHttpBindingBase.cs
• TextTreeText.cs
• ApplicationManager.cs
• SessionPageStatePersister.cs
• TreeNode.cs
• HtmlProps.cs
• HtmlWindow.cs