private static EventLogEntryType EventLogEntryTypeFromEventType(TraceEventType type)
{
EventLogEntryType eventLogEntryType = EventLogEntryType.Information;
TraceEventType traceEventType = type;
switch (traceEventType)
{
case TraceEventType.Critical:
case TraceEventType.Error:
{
eventLogEntryType = EventLogEntryType.Error;
return eventLogEntryType;
}
case TraceEventType.Critical | TraceEventType.Error:
{
return eventLogEntryType;
}
case TraceEventType.Warning:
{
eventLogEntryType = EventLogEntryType.Warning;
return eventLogEntryType;
}
default:
{
return eventLogEntryType;
}
}
}
public void AddNewItemToTraceList(TraceEventType eventType, string message)
{
LogEntry leNewTraceItem = new LogEntry();
leNewTraceItem.Message = message;
leNewTraceItem.Severity = eventType;
leNewTraceItem.TimeStamp = DateTime.Now;
lock (lockObject)
{
lstFreshTrace.Add(leNewTraceItem);
if ( eventType == TraceEventType.Critical || eventType == TraceEventType.Error || eventType == TraceEventType.Warning )
{
lstFreshTraceErrors.Add(leNewTraceItem);
}
if ( lstFreshTraceErrors.Count > errorsNumber )
{
lstFreshTraceErrors.RemoveAt(0);
}
if (lstFreshTrace.Count > infoNumber)
{
lstFreshTrace.RemoveAt(0);
}
}
}
LoggingLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType)
{
_name = name;
_index = index;
_sourceLevel = sourceLevel;
_traceEventType = traceEventType;
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
{
if ((this.Filter == null) || this.Filter.ShouldTrace(eventCache, source, eventType, id, message, null, null, null))
{
this.WriteLine(message);
}
}
static Level DefaultGetLogLevel(TraceEventType traceEventType)
{
switch (traceEventType)
{
case TraceEventType.Critical:
return Level.Fatal;
case TraceEventType.Error:
return Level.Error;
case TraceEventType.Warning:
return Level.Warn;
case TraceEventType.Information:
return Level.Info;
case TraceEventType.Verbose:
return Level.Trace;
case TraceEventType.Start:
return Level.Debug;
case TraceEventType.Stop:
return Level.Debug;
case TraceEventType.Suspend:
return Level.Debug;
case TraceEventType.Resume:
return Level.Debug;
case TraceEventType.Transfer:
return Level.Debug;
default:
throw new ArgumentOutOfRangeException("traceEventType");
}
}
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
tracedData = data;
tracedSource = source;
tracedEventType = eventType;
entries.Add(data as LogEntry);
}
private static LogLevels? ToStockSharp(TraceEventType eventType)
{
switch (eventType)
{
case TraceEventType.Critical:
case TraceEventType.Error:
return LogLevels.Error;
case TraceEventType.Warning:
return LogLevels.Warning;
case TraceEventType.Information:
return LogLevels.Info;
case TraceEventType.Verbose:
return LogLevels.Debug;
case TraceEventType.Start:
case TraceEventType.Stop:
case TraceEventType.Suspend:
case TraceEventType.Resume:
case TraceEventType.Transfer:
return null;
default:
throw new ArgumentOutOfRangeException("eventType");
}
}
private EtwEventLevel ConvertTraceEventTypeToEventLevel(TraceEventType eventType)
{
EtwEventLevel verbose = EtwEventLevel.Verbose;
switch (eventType)
{
case TraceEventType.Critical:
return EtwEventLevel.Critical;
case TraceEventType.Error:
return EtwEventLevel.Error;
case (TraceEventType.Error | TraceEventType.Critical):
return verbose;
case TraceEventType.Warning:
return EtwEventLevel.Warning;
case TraceEventType.Information:
return EtwEventLevel.Information;
case TraceEventType.Verbose:
return EtwEventLevel.Verbose;
}
return verbose;
}
public void Log(string message, TraceEventType eventType)
{
foreach (ILogger logger in this.loggers)
{
logger.Log(message, eventType);
}
}
internal bool ShouldLog(TraceEventType severity, LogPriority priority, IEnumerable<LogCategory> categories)
{
return
ShouldLog(severity, "All") ||
ShouldLog(severity, priority.ToString()) ||
categories.Any(c => ShouldLog(severity, c.ToString()));
}
protected static bool DefaultIsLogEventEnabled(ILog commonLog, TraceEventType traceEventType)
{
switch (traceEventType)
{
case TraceEventType.Critical:
return commonLog.IsFatalEnabled;
case TraceEventType.Error:
return commonLog.IsErrorEnabled;
case TraceEventType.Warning:
return commonLog.IsWarnEnabled;
case TraceEventType.Information:
return commonLog.IsInfoEnabled;
case TraceEventType.Verbose:
return commonLog.IsTraceEnabled;
case TraceEventType.Start:
return commonLog.IsDebugEnabled;
case TraceEventType.Stop:
return commonLog.IsDebugEnabled;
case TraceEventType.Suspend:
return commonLog.IsDebugEnabled;
case TraceEventType.Resume:
return commonLog.IsDebugEnabled;
case TraceEventType.Transfer:
return commonLog.IsDebugEnabled;
default:
throw new ArgumentOutOfRangeException("traceEventType");
}
}
LogLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType)
{
Name = name;
_index = index;
SourceLevel = sourceLevel;
TraceEventType = traceEventType;
}
void Trace(TraceEventType eventType, string message)
{
if (this.Switch.ShouldTrace(eventType) && this.Listeners != null)
{
TraceEvent(eventType, 0, m_header + message);
}
}
internal MyLoggingExceptionHandler(string logCategory, int eventId, TraceEventType severity, string title, int priority,
Type formatterType, LogWriter writer, DocumentModel doc)
: base(logCategory, eventId, severity, title, priority, formatterType, writer)
{
this.m_Writer = writer;
this.doc = doc;
}
private LogLevel Map(TraceEventType eventType)
{
switch (eventType)
{
case TraceEventType.Critical:
return LogLevel.Fatal;
case TraceEventType.Error:
return LogLevel.Error;
case TraceEventType.Warning:
return LogLevel.Warn;
case TraceEventType.Information:
return LogLevel.Info;
case TraceEventType.Verbose:
return LogLevel.Trace;
case TraceEventType.Start:
return LogLevel.Info;
case TraceEventType.Stop:
return LogLevel.Info;
case TraceEventType.Suspend:
return LogLevel.Info;
case TraceEventType.Resume:
return LogLevel.Info;
case TraceEventType.Transfer:
return LogLevel.Info;
default:
throw new ArgumentOutOfRangeException("eventType");
}
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
{
try
{
var dict = message.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries)
.Select(part => part.Split('='))
.ToDictionary(split => split[0], split => split[1]);
string iid;
if (dict.TryGetValue("iid", out iid))
{
string toWrite = string.Format("[{0} {1}] {2}", DateTime.Now, iid, dict["msg"]);
base.WriteLine(toWrite);
}
else
{
string toWrite = string.Format("[{0}] {1}", DateTime.Now, dict["msg"]);
base.WriteLine(toWrite);
}
}
catch (Exception exception)
{
string toWrite = string.Format("Exception while parsing trace: {0}\n\t", exception.Message, exception.StackTrace);
base.WriteLine(toWrite);
}
}
private static EventLevel GetLogLevel(TraceEventType traceEventType)
{
switch (traceEventType)
{
case TraceEventType.Critical:
return EventLevel.Critical;
case TraceEventType.Error:
return EventLevel.Error;
case TraceEventType.Warning:
return EventLevel.Warning;
case TraceEventType.Information:
return EventLevel.Informational;
case TraceEventType.Verbose:
case TraceEventType.Start:
case TraceEventType.Stop:
case TraceEventType.Suspend:
case TraceEventType.Resume:
case TraceEventType.Transfer:
return EventLevel.Verbose;
default:
throw new ArgumentOutOfRangeException(nameof(traceEventType));
}
}
protected override void TraceSimpleEvent(DateTime eventTime, Int32 threadId, TraceEventType eventType, String message, Int32 eventId, TraceEventCache eventCache, String source)
{
if (this._traceListener != null)
{
this._traceListener.TraceEvent(eventCache, source, eventType, eventId, message);
}
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args)
{
if (Filter != null && !Filter.ShouldTrace(eventCache, source, eventType, id, format, args, null, null))
{
return;
}
var client = new SmtpClient(Settings.Default.SmtpServer)
{
Credentials = new NetworkCredential(Settings.Default.SmtpUsername, Settings.Default.SmtpPassword),
EnableSsl = true
};
var body = string.Format(format, args);
var firstLine = new StringReader(body).ReadLine();
if (firstLine.Length > 100)
{
firstLine = firstLine.Substring(0, 97).Trim() + "...";
}
var msg = new MailMessage
{
From = new MailAddress(Settings.Default.NotificationFrom, "FitBot"),
To = {Settings.Default.NotificationTo},
Subject = $"{eventType} - {firstLine}",
Body = body
};
client.Send(msg);
}
public override sealed void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
{
if ((base.Filter == null) || base.Filter.ShouldTrace(eventCache, source, eventType, id, message, null, null, null))
{
WriteTrace(eventCache, source, eventType, id, message, null, null);
}
}
/// <summary>
///
/// </summary>
/// <param name="severity"></param>
/// <returns></returns>
private Action<object, Exception> GenerateLog(TraceEventType severity)
{
switch (severity)
{
case TraceEventType.Error:
return LogError.Error;
case TraceEventType.Information:
return LogInfo.Info;
case TraceEventType.Warning:
return LogWarm.Warn;
case TraceEventType.Critical:
break;
case TraceEventType.Verbose:
break;
case TraceEventType.Start:
break;
case TraceEventType.Stop:
break;
case TraceEventType.Suspend:
break;
case TraceEventType.Resume:
break;
case TraceEventType.Transfer:
break;
default:
return LogInfo.Info;
}
return LogInfo.Info;
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
{
var te = new TraceEvent {Cache = eventCache, Source = source, Type = eventType, Id = id};
Events.Add(te);
if (OnEventAdd != null)
OnEventAdd.Invoke(te);
}
/// <summary>
/// Determines whether a filter is attached to this listener and, if so, asks whether it ShouldTrace applies to this data.
/// </summary>
protected virtual bool ShouldTrace(TraceEventCache eventCache, string source, TraceEventType eventType, int id,
string formatOrMessage, object[] args, object data1, object[] data)
{
return
!(Filter != null &&
!Filter.ShouldTrace(eventCache, source, eventType, id, formatOrMessage, args, data1, data));
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
{
this.source = source;
this.eventType = eventType;
this.id = id;
TraceEvent(eventCache, source, eventType, id, "No additional information.");
}
public DebugConsoleMessageEventArgs(DateTime timestamp, string message, TraceEventType level, string source)
{
Timestamp = timestamp;
Message = message;
Level = level;
Source = source;
}
private void Trace(TraceEventType type, string message, params object[] parameters)
{
if (category.Source.Switch.ShouldTrace(type))
{
category.Source.TraceEvent(type, EVENT_ID, message, parameters);
}
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
{
if (_enabled)
{
WebSocketHost.Send($"{eventType}:{id} - {source}");
}
}
/// <summary>
/// Returns the value of Environment.MachineName
/// </summary>
/// <param name="value">The output parameter</param>
/// <param name="cache">Unused</param>
/// <param name="source">Unused</param>
/// <param name="eventType">Unused</param>
/// <param name="id">Unused</param>
/// <param name="formatOrMessage">Unused</param>
/// <param name="data">Unused</param>
/// <returns>True</returns>
public override bool TryGetValue(out object value, TraceEventCache cache, string source,
TraceEventType eventType, int id, string formatOrMessage,
object[] data)
{
value = Environment.MachineName;
return true;
}
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id,
params object[] data)
{
if (this.Filter != null &&
!this.Filter.ShouldTrace(eventCache, source, eventType, id, string.Empty, null, null, null))
return;
foreach (object obj in data)
{
if (obj is XPathNavigator)
{
using (var reader = ((XPathNavigator)obj).ReadSubtree())
{
reader.MoveToContent();
if (reader.IsStartElement())
Console.WriteLine(XElement.ReadFrom(reader).ToString(SaveOptions.OmitDuplicateNamespaces));
else
{
Console.WriteLine("Unable to write Xml data.");
}
}
}
else
{
Console.WriteLine(obj.ToString());
}
}
}
public override sealed void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data)
{
if ((base.Filter == null) || base.Filter.ShouldTrace(eventCache, source, eventType, id, null, null, null, data))
{
WriteTrace(eventCache, source, eventType, id, null, null, data);
}
}
private static void WriteEvent(TraceEventType eventType, CompositionTraceId traceId, string format, params object[] arguments)
{
Source.TraceEvent(eventType, (int)traceId, format, arguments);
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args)
{
base.TraceEvent(eventCache, source, eventType, id, format, args);
if (format.StartsWith("Storyboard has begun;"))
{
TriggerTraceStoryboard storyboard = args[1] as TriggerTraceStoryboard;
if (storyboard != null)
{
// add a breakpoint here to see when your trigger has been
// entered or exited
// the element being acted upon
object targetElement = args[5];
// the namescope of the element being acted upon
INameScope namescope = (INameScope)args[7];
TriggerBase triggerBase = storyboard.TriggerBase;
string triggerName = GetTriggerName(storyboard.TriggerBase);
Debug.WriteLine(string.Format("Element: {0}, {1}: {2}: {3}",
targetElement,
triggerBase.GetType().Name,
triggerName,
storyboard.StoryboardType));
}
}
}
public void Log(string message, TraceEventType eventType)
{
}
/// <summary>
/// Writes trace information, a formatted array of objects and event information to the listener specific output.
/// </summary>
/// <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param>
/// <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
/// <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType"/> values specifying the type of event that has caused the trace.</param>
/// <param name="id">A numeric identifier for the event.</param>
/// <param name="format">A format string that contains zero or more format items, which correspond to objects in the <paramref name="args"/> array.</param>
/// <param name="args">An object array containing zero or more objects to format.</param>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.EnvironmentPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true"/>
/// <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode"/>
/// </PermissionSet>
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args)
{
// Call overload
TraceEvent(eventCache, source, eventType, id, string.Format(format, args));
}
public void Event(TraceEventType type, TraceMessage message)
{
Console.WriteLine("{0} {1}", type, message);
}
/// <summary>
/// Indicates if the specified <paramref name="eventType"/> is enable and should produce a trace.
/// </summary>
/// <param name="eventType">An indication of the type of trace event.</param>
/// <returns>Returns true when the specified <paramref name="eventType"/> should produce a trace.</returns>
public bool ShouldTrace(TraceEventType eventType)
{
return(_traceSource.Switch.ShouldTrace(eventType));
}
public void Write(object message, ICollection <string> categories, int priority, int eventId, TraceEventType severity, string title,
IDictionary <string, object> properties)
{
Entries.Add(new EventLogEntryForTests(message, categories, priority, eventId, severity, title, properties));
}
private static void Trace(TraceEventType eventType, string message)
{
Trace(eventType, "{0}", message);
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
{
TraceEvent(eventCache, source, eventType, id, string.Empty);
}
private static void Trace(TraceEventType eventType, string format, params object[] args)
{
Trace(_tracer, eventType, format, args);
}
public static bool IsSeverityEnabled(TraceEventType severity)
{
bool enabled = severity <= _minimalSeverity ? true : false;
return(enabled);
}
// These methods are not currently supported because they are not necessary.
// However, they have sufficient parameters to properly identify the event.
#region NotSupported but might be reasonable to support
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
throw new NotSupportedException();
}
public void Write(string title, TraceEventType traceEventType)
{
Write(title, null, traceEventType);
}
// Write record to file
static private void _CreateLogRecord(Exception ex, TraceEventType currentSeverity)
{
string logMessage = _GetLogMessage(ex);
_CreateLogRecord(logMessage, currentSeverity);
}
protected void Log(TraceEventType severity, string message, params object[] args)
{
OnWriteLog(severity, String.Format(CultureInfo.CurrentCulture, message, args));
}
public abstract void Log(TraceEventType logEvent);
/// <summary>
/// Writes trace information, a message, and event information to the listener specific output.
/// </summary>
/// <param name="eventCache">A TraceEventCache object that contains the current process ID, thread ID, and stack trace information.</param>
/// <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
/// <param name="eventType">One of the TraceEventType values specifying the type of event that has caused the trace.</param>
/// <param name="id">A numeric identifier for the event.</param>
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id)
{
this.TraceEvent(eventCache, source, eventType, id, id.ToString(CultureInfo.InvariantCulture));
}
/// <inheritdoc />
/// <remarks>
/// This method calls the underlying property reader to obtain its value, and then if the obeject returned implements
/// the <see cref="System.IFormattable"/> interface we then call .ToString(FormatString) on it and return the
/// formatted version of the data.
/// </remarks>
public override bool TryGetValue(out object value, TraceEventCache cache, string source, TraceEventType eventType, int id, string formatOrMessage, object[] data)
{
object subval = null;
if (_wrappedPropertyReader.TryGetValue(out subval, cache, source, eventType, id, formatOrMessage, data))
{
value = subval;
IFormattable formattable = subval as IFormattable;
if (formattable != null)
{
value = formattable.ToString(FormatString, CultureInfo.InvariantCulture);
}
return(true);
}
value = null;
return(false);
}
public void Log(string message, TraceEventType eventType)
{
Console.WriteLine("{0:G} - {1}: {2}", DateTime.Now, eventType, message);
}
protected abstract void OnWriteLog(TraceEventType severity, string message);
public static void WriteLog(int eventId, int priority, string message, string category, TraceEventType traceEventType, string moduleName)
{
LogEntry logEntry = new LogEntry();
logEntry.EventId = eventId;
logEntry.Priority = priority;
logEntry.Message = message;
logEntry.Categories.Add(category);
logEntry.Severity = traceEventType;
logEntry.Title = moduleName;
Logger.Write(logEntry);
}
public virtual void Log(TraceEventType logEvent)
{
}
internal void LogEvent(TraceEventType type, EventLogCategory category, EventLogEventId eventId, params string[] values)
{
this.LogEvent(type, category, eventId, true, values);
}
/// <summary>
/// Initialize a new instance of a <see cref="XmlLogEntry"/> class.
/// </summary>
/// <param name="message"></param>
/// <param name="category"></param>
/// <param name="priority"></param>
/// <param name="eventId"></param>
/// <param name="severity"></param>
/// <param name="title"></param>
/// <param name="properties"></param>
public XmlLogEntry(object message, ICollection <string> category, int priority, int eventId, TraceEventType severity, string title, IDictionary <string, object> properties) : base(message, category, priority, eventId, severity, title, properties)
{
}
bool ShouldTrace(TraceEventCache cache, string source, TraceEventType eventType, int id, string formatOrMessage,
object[] args, object data1, object[] data)
{
return(Filter?.ShouldTrace(cache, source, eventType, id, formatOrMessage, args, data1, data) ?? true);
}
internal void LogEvent(TraceEventType type, EventLogCategory category, EventLogEventId eventId, bool shouldTrace, params string[] values)
{
try
{
int length = 0;
string[] strArrays = new string[(int)values.Length + 2];
for (int i = 0; i < (int)values.Length; i++)
{
string str = values[i];
str = (string.IsNullOrEmpty(str) ? string.Empty : EventLogger.NormalizeEventLogParameter(str));
strArrays[i] = str;
length = length + str.Length + 1;
}
string str1 = EventLogger.NormalizeEventLogParameter(DiagnosticTrace.ProcessName);
strArrays[(int)strArrays.Length - 2] = str1;
length = length + str1.Length + 1;
string str2 = DiagnosticTrace.ProcessId.ToString(CultureInfo.InvariantCulture);
strArrays[(int)strArrays.Length - 1] = str2;
length = length + str2.Length + 1;
if (length > 25600)
{
int num = 25600 / (int)strArrays.Length - 1;
for (int j = 0; j < (int)strArrays.Length; j++)
{
if (strArrays[j].Length > num)
{
strArrays[j] = strArrays[j].Substring(0, num);
}
}
}
using (SafeEventLogWriteHandle safeEventLogWriteHandle = SafeEventLogWriteHandle.RegisterEventSource(null, this.eventLogSourceName))
{
if (safeEventLogWriteHandle != null)
{
SecurityIdentifier user = WindowsIdentity.GetCurrent().User;
byte[] numArray = new byte[user.BinaryLength];
user.GetBinaryForm(numArray, 0);
IntPtr[] intPtrArray = new IntPtr[(int)strArrays.Length];
GCHandle gCHandle = GCHandle.Alloc(intPtrArray, GCHandleType.Pinned);
GCHandle[] gCHandleArray = null;
try
{
gCHandleArray = new GCHandle[(int)strArrays.Length];
for (int k = 0; k < (int)strArrays.Length; k++)
{
gCHandleArray[k] = GCHandle.Alloc(strArrays[k], GCHandleType.Pinned);
intPtrArray[k] = gCHandleArray[k].AddrOfPinnedObject();
}
HandleRef handleRef = new HandleRef(safeEventLogWriteHandle, gCHandle.AddrOfPinnedObject());
Microsoft.ServiceBus.Diagnostics.NativeMethods.ReportEvent(safeEventLogWriteHandle, (ushort)EventLogger.EventLogEntryTypeFromEventType(type), (ushort)category, (uint)eventId, numArray, (ushort)((int)strArrays.Length), 0, handleRef, null);
}
finally
{
if (gCHandle.AddrOfPinnedObject() != IntPtr.Zero)
{
gCHandle.Free();
}
if (gCHandleArray != null)
{
GCHandle[] gCHandleArray1 = gCHandleArray;
for (int l = 0; l < (int)gCHandleArray1.Length; l++)
{
gCHandleArray1[l].Free();
}
}
}
}
}
if (shouldTrace && this.diagnosticTrace != null)
{
Dictionary <string, string> strs = new Dictionary <string, string>((int)strArrays.Length + 4);
strs["CategoryID.Name"] = category.ToString();
strs["CategoryID.Value"] = category.ToString(CultureInfo.InvariantCulture);
strs["InstanceID.Name"] = eventId.ToString();
strs["InstanceID.Value"] = eventId.ToString(CultureInfo.InvariantCulture);
for (int m = 0; m < (int)values.Length; m++)
{
strs.Add(string.Concat("Value", m.ToString(CultureInfo.InvariantCulture)), (values[m] == null ? string.Empty : DiagnosticTrace.XmlEncode(values[m])));
}
this.diagnosticTrace.TraceEvent(type, TraceCode.EventLog, Microsoft.ServiceBus.SR.GetString(Resources.TraceCodeEventLog, new object[0]), new DictionaryTraceRecord(strs), null, null);
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
}
}
public void TraceData(TraceEventType eventType, int id, params object[] data)
{
Trace.TraceData(eventType, id, data);
}
public static void 设置(Action <M日志> __记录信息, TraceEventType __等级 = TraceEventType.Information)
{
_记录信息 = __记录信息;
_等级 = __等级;
}
public void TraceEvent(TraceEventType eventType, int id, string format, params object[] args)
{
Trace.TraceEvent(eventType, id, format, args);
}
public void TraceData(TraceEventType eventType, int id, object data)
{
Trace.TraceData(eventType, id, data);
}
