mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
486 lines
19 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|
|
}
|