Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

486 lines
19 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Runtime;
using System.Runtime.Diagnostics;
using System.ServiceModel.Diagnostics;
using System.ServiceModel.Diagnostics.Application;
using System.Xml;
static class MsmqDiagnostics
{
public static void CannotPeekOnQueue(string formatName, Exception ex)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
TraceCode.MsmqCannotPeekOnQueue,
SR.GetString(SR.TraceCodeMsmqCannotPeekOnQueue),
new StringTraceRecord("QueueFormatName", formatName),
null,
ex);
}
}
public static void CannotReadQueues(string host, bool publicQueues, Exception ex)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(2);
dictionary["Host"] = host;
dictionary["PublicQueues"] = Convert.ToString(publicQueues, CultureInfo.InvariantCulture);
TraceUtility.TraceEvent(
TraceEventType.Warning,
TraceCode.MsmqCannotReadQueues,
SR.GetString(SR.TraceCodeMsmqCannotReadQueues),
new DictionaryTraceRecord(dictionary),
null,
ex);
}
}
public static ServiceModelActivity StartListenAtActivity(MsmqReceiveHelper receiver)
{
ServiceModelActivity activity = receiver.Activity;
if (DiagnosticUtility.ShouldUseActivity && null == activity)
{
activity = ServiceModelActivity.CreateActivity(true);
if (null != FxTrace.Trace)
{
FxTrace.Trace.TraceTransfer(activity.Id);
}
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityListenAt, receiver.ListenUri.ToString()), ActivityType.ListenAt);
}
return activity;
}
public static Activity BoundOpenOperation(MsmqReceiveHelper receiver)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.TransportListen,
SR.GetString(SR.TraceCodeTransportListen, receiver.ListenUri.ToString()),
receiver);
}
return ServiceModelActivity.BoundOperation(receiver.Activity);
}
public static Activity BoundReceiveOperation(MsmqReceiveHelper receiver)
{
if (DiagnosticUtility.ShouldUseActivity && null != ServiceModelActivity.Current && ActivityType.ProcessAction != ServiceModelActivity.Current.ActivityType)
{
return ServiceModelActivity.BoundOperation(receiver.Activity);
}
else
{
return null;
}
}
public static ServiceModelActivity BoundDecodeOperation()
{
ServiceModelActivity activity = null;
if (DiagnosticUtility.ShouldUseActivity)
{
activity = ServiceModelActivity.CreateBoundedActivity(true);
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityProcessingMessage, TraceUtility.RetrieveMessageNumber()), ActivityType.ProcessMessage);
}
return activity;
}
public static ServiceModelActivity BoundReceiveBytesOperation()
{
ServiceModelActivity activity = null;
if (DiagnosticUtility.ShouldUseActivity)
{
activity = ServiceModelActivity.CreateBoundedActivityWithTransferInOnly(Guid.NewGuid());
ServiceModelActivity.Start(activity, SR.GetString(SR.ActivityReceiveBytes, TraceUtility.RetrieveMessageNumber()), ActivityType.ReceiveBytes);
}
return activity;
}
public static void TransferFromTransport(Message message)
{
if (DiagnosticUtility.ShouldUseActivity)
{
TraceUtility.TransferFromTransport(message);
}
}
public static void ExpectedException(Exception ex)
{
DiagnosticUtility.TraceHandledException(ex, TraceEventType.Information);
}
public static void ScanStarted()
{
if (DiagnosticUtility.ShouldTraceVerbose)
{
TraceUtility.TraceEvent(
TraceEventType.Verbose,
TraceCode.MsmqScanStarted,
SR.GetString(SR.TraceCodeMsmqScanStarted),
null,
null,
null);
}
}
public static void MatchedApplicationFound(string host, string queueName, bool isPrivate, string canonicalPath)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(4);
dictionary["Host"] = host;
dictionary["QueueName"] = queueName;
dictionary["Private"] = Convert.ToString(isPrivate, CultureInfo.InvariantCulture);
dictionary["CanonicalPath"] = canonicalPath;
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqMatchedApplicationFound,
SR.GetString(SR.TraceCodeMsmqMatchedApplicationFound),
new DictionaryTraceRecord(dictionary),
null,
null);
}
}
public static void StartingApplication(string application)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqStartingApplication,
SR.GetString(SR.TraceCodeMsmqStartingApplication),
new StringTraceRecord("Application", application),
null,
null);
}
}
public static void StartingService(string host, string name, bool isPrivate, string processedVirtualPath)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(4);
dictionary["Host"] = host;
dictionary["Name"] = name;
dictionary["Private"] = Convert.ToString(isPrivate, CultureInfo.InvariantCulture);
dictionary["VirtualPath"] = processedVirtualPath;
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqStartingService,
SR.GetString(SR.TraceCodeMsmqStartingService),
new DictionaryTraceRecord(dictionary),
null,
null);
}
}
public static void FoundBaseAddress(Uri uri, string virtualPath)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(2)
{
{ "Uri", uri.ToString() },
{ "VirtualPath", virtualPath }
};
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqFoundBaseAddress,
SR.GetString(SR.TraceCodeMsmqFoundBaseAddress),
new DictionaryTraceRecord(dictionary),
null,
null);
}
}
static void DatagramSentOrReceived(NativeMsmqMessage.BufferProperty messageId, Message message, int traceCode, string traceDescription)
{
if (DiagnosticUtility.ShouldTraceVerbose)
{
Guid msmqId = MessageIdToGuid(messageId);
UniqueId indigoId = message.Headers.MessageId;
TraceRecord record = null;
if (null == indigoId)
{
record = new StringTraceRecord("MSMQMessageId", msmqId.ToString());
}
else
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(2)
{
{ "MSMQMessageId", msmqId.ToString() },
{ "WCFMessageId", indigoId.ToString() }
};
record = new DictionaryTraceRecord(dictionary);
}
TraceUtility.TraceEvent(TraceEventType.Verbose, traceCode, traceDescription, record, null, null);
}
}
public static void DatagramReceived(NativeMsmqMessage.BufferProperty messageId, Message message)
{
DatagramSentOrReceived(messageId, message, TraceCode.MsmqDatagramReceived, SR.GetString(SR.TraceCodeMsmqDatagramReceived));
}
public static void DatagramSent(NativeMsmqMessage.BufferProperty messageId, Message message)
{
DatagramSentOrReceived(messageId, message, TraceCode.MsmqDatagramSent, SR.GetString(SR.TraceCodeMsmqDatagramSent));
}
static Guid MessageIdToGuid(NativeMsmqMessage.BufferProperty messageId)
{
if (UnsafeNativeMethods.PROPID_M_MSGID_SIZE != messageId.Buffer.Length)
Fx.Assert(String.Format("Unexpected messageId size: {0}", messageId.Buffer.Length));
byte[] buffer = new byte[16];
Buffer.BlockCopy(messageId.Buffer, 4, buffer, 0, 16);
return new Guid(buffer);
}
public static void MessageConsumed(string uri, string messageId, bool rejected)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
rejected ? TraceCode.MsmqMessageRejected : TraceCode.MsmqMessageDropped,
rejected ? SR.GetString(SR.TraceCodeMsmqMessageRejected) : SR.GetString(SR.TraceCodeMsmqMessageDropped),
new StringTraceRecord("MSMQMessageId", messageId),
null,
null);
}
if (PerformanceCounters.PerformanceCountersEnabled)
{
if (rejected)
{
PerformanceCounters.MsmqRejectedMessage(uri);
}
else
{
PerformanceCounters.MsmqDroppedMessage(uri);
}
}
}
public static void MessageLockedUnderTheTransaction(long lookupId)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
TraceCode.MsmqMessageLockedUnderTheTransaction,
SR.GetString(SR.TraceCodeMsmqMessageLockedUnderTheTransaction),
new StringTraceRecord("MSMQMessageLookupId", Convert.ToString(lookupId, CultureInfo.InvariantCulture)),
null,
null);
}
}
public static void MoveOrDeleteAttemptFailed(long lookupId)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
TraceCode.MsmqMoveOrDeleteAttemptFailed,
SR.GetString(SR.TraceCodeMsmqMoveOrDeleteAttemptFailed),
new StringTraceRecord("MSMQMessageLookupId", Convert.ToString(lookupId, CultureInfo.InvariantCulture)),
null,
null);
}
}
public static void MsmqDetected(Version version)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqDetected,
SR.GetString(SR.TraceCodeMsmqDetected),
new StringTraceRecord("MSMQVersion", version.ToString()),
null,
null);
}
}
public static void PoisonMessageMoved(string messageId, bool poisonQueue, string uri)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
poisonQueue ? TraceCode.MsmqPoisonMessageMovedPoison : TraceCode.MsmqPoisonMessageMovedRetry,
poisonQueue ? SR.GetString(SR.TraceCodeMsmqPoisonMessageMovedPoison) : SR.GetString(SR.TraceCodeMsmqPoisonMessageMovedRetry),
new StringTraceRecord("MSMQMessageId", messageId),
null,
null);
}
if (poisonQueue && PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.MsmqPoisonMessage(uri);
}
}
public static void PoisonMessageRejected(string messageId, string uri)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
TraceCode.MsmqPoisonMessageRejected,
SR.GetString(SR.TraceCodeMsmqPoisonMessageRejected),
new StringTraceRecord("MSMQMessageId", messageId),
null,
null);
}
if (PerformanceCounters.PerformanceCountersEnabled)
{
PerformanceCounters.MsmqPoisonMessage(uri);
}
}
static bool poolFullReported = false;
public static void PoolFull(int poolSize)
{
if (DiagnosticUtility.ShouldTraceInformation && !poolFullReported)
{
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqPoolFull,
SR.GetString(SR.TraceCodeMsmqPoolFull),
null,
null,
null);
poolFullReported = true;
}
}
public static void PotentiallyPoisonMessageDetected(string messageId)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
TraceCode.MsmqPotentiallyPoisonMessageDetected,
SR.GetString(SR.TraceCodeMsmqPotentiallyPoisonMessageDetected),
new StringTraceRecord("MSMQMessageId", messageId),
null,
null);
}
}
public static void QueueClosed(string formatName)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqQueueClosed,
SR.GetString(SR.TraceCodeMsmqQueueClosed),
new StringTraceRecord("FormatName", formatName),
null,
null);
}
}
public static void QueueOpened(string formatName)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(
TraceEventType.Information,
TraceCode.MsmqQueueOpened,
SR.GetString(SR.TraceCodeMsmqQueueOpened),
new StringTraceRecord("FormatName", formatName),
null,
null);
}
}
public static void QueueTransactionalStatusUnknown(string formatName)
{
if (DiagnosticUtility.ShouldTraceWarning)
{
TraceUtility.TraceEvent(
TraceEventType.Warning,
TraceCode.MsmqQueueTransactionalStatusUnknown,
SR.GetString(SR.TraceCodeMsmqQueueTransactionalStatusUnknown),
new StringTraceRecord("FormatName", formatName),
null,
null);
}
}
public static void SessiongramSent(string sessionId, NativeMsmqMessage.BufferProperty messageId, int numberOfMessages)
{
if (DiagnosticUtility.ShouldTraceVerbose)
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(3);
dictionary["SessionId"] = sessionId;
dictionary["MSMQMessageId"] = MsmqMessageId.ToString(messageId.Buffer);
dictionary["NumberOfMessages"] = Convert.ToString(numberOfMessages, CultureInfo.InvariantCulture);
TraceUtility.TraceEvent(
TraceEventType.Verbose,
TraceCode.MsmqSessiongramSent,
SR.GetString(SR.TraceCodeMsmqSessiongramSent),
new DictionaryTraceRecord(dictionary),
null,
null);
}
}
public static void SessiongramReceived(string sessionId, NativeMsmqMessage.BufferProperty messageId, int numberOfMessages)
{
if (DiagnosticUtility.ShouldTraceVerbose)
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(3);
dictionary["SessionId"] = sessionId;
dictionary["MSMQMessageId"] = MsmqMessageId.ToString(messageId.Buffer);
dictionary["NumberOfMessages"] = Convert.ToString(numberOfMessages, CultureInfo.InvariantCulture);
TraceUtility.TraceEvent(
TraceEventType.Verbose,
TraceCode.MsmqSessiongramReceived,
SR.GetString(SR.TraceCodeMsmqSessiongramReceived),
new DictionaryTraceRecord(dictionary),
null,
null);
}
}
public static void UnexpectedAcknowledgment(string messageId, int acknowledgment)
{
if (DiagnosticUtility.ShouldTraceVerbose)
{
Dictionary<string, string> dictionary = new Dictionary<string, string>(2);
dictionary["MSMQMessageId"] = messageId;
dictionary["Acknowledgment"] = Convert.ToString(acknowledgment, CultureInfo.InvariantCulture);
TraceUtility.TraceEvent(
TraceEventType.Verbose,
TraceCode.MsmqUnexpectedAcknowledgment,
SR.GetString(SR.TraceCodeMsmqUnexpectedAcknowledgment),
new DictionaryTraceRecord(dictionary),
null,
null);
}
}
}
}