/// <summary>
/// Changes the console formatting options for the specified event type
/// and returns an object that, when disposed, resets the settings to
/// their previous values.
/// </summary>
/// <param name="e">The type of event to format for.</param>
/// <returns>
/// An <see cref="IDisposable"/> that will return the settings to their
/// previous values.
/// </returns>
protected virtual IDisposable FormatForLogLevel(TraceEventType?e)
{
switch (e)
{
case TraceEventType.Critical:
return(new ConsoleHighlight(ConsoleColor.White, ConsoleColor.Red));
case TraceEventType.Error:
return(new ConsoleHighlight(ConsoleColor.Red));
case TraceEventType.Warning:
return(new ConsoleHighlight(ConsoleColor.Yellow));
case TraceEventType.Information:
return(new ConsoleHighlight(ConsoleColor.Green));
case TraceEventType.Verbose:
case TraceEventType.Start:
case TraceEventType.Stop:
case TraceEventType.Resume:
case TraceEventType.Transfer:
return(new ConsoleHighlight(ConsoleColor.Gray));
}
return(new ConsoleHighlight());
}
public static string GetSubjectPrefix(Exception ex = null, TraceEventType?type = null)
{
var asm = Assembly.GetEntryAssembly();
string s = "Unknown Entry Assembly";
if (asm == null && ex != null)
{
var frames = new StackTrace(ex).GetFrames();
if (frames != null && frames.Length > 0)
{
asm = frames[0].GetMethod().DeclaringType.Assembly;
}
}
if (asm == null)
{
asm = Assembly.GetCallingAssembly();
}
if (asm != null)
{
var last2Nodes = asm.GetName().Name.Split('.').Reverse().Take(2).Reverse();
s = string.Join(".", last2Nodes);
}
if (type.HasValue)
{
s += string.Format(" {0}", type);
}
ApplyRunModeSuffix(ref s);
s += ": ";
return(s);
}
/*
* Queria ter feito um metodo que recebece o TraceSource e grave em um arquivo
* Mas deu para entender como gravar em um arquivo
* Obs.: Código desse 'cs' totalmente fora dos padrões de programação.
*/
public static void WriteTraceInFile(Stream myFile, string msg, TraceEventType?typeTrace)
{
// Create a file for output named LogTrace.txt.
//Stream myFile = File.Create(@"..\\..\\Log\\LogTrace.txt");
Trace.AutoFlush = true;//Libera o conteudo automaticamentem
/* Create a new i writer using the output stream, and add it to
* the trace listeners.
*/
TextWriterTraceListener myTextListener = new TextWriterTraceListener(myFile);
Trace.Listeners.Add(myTextListener);
//Trace.Listeners.AddRange(traceSource.Listeners);
//Trace.WriteLine(string.Format("{0:G} -",DateTime.Now));
switch (typeTrace)
{
case TraceEventType.Information:
Trace.TraceInformation(msg);
break;
case TraceEventType.Critical:
Trace.TraceWarning(msg);
break;
case TraceEventType.Error:
Trace.TraceError(msg);
break;
}
// Flush the output.
Trace.Flush();
}
/// <summary>
/// Write out the log4net XML message based on the trace event data provided.
/// </summary>
/// <param name="timestamp">The date and time when the trace event occurred.</param>
/// <param name="level">The trace event level.</param>
/// <param name="logger">The trace source name or category.</param>
/// <param name="message">The message to log.</param>
private void WriteEvent(DateTime timestamp, TraceEventType?level, String logger, String message)
{
var xml = new StringBuilder();
using (var stringWriter = new StringWriter(xml))
using (var xmlWriter = new XmlTextWriter(stringWriter))
{
xmlWriter.WriteStartElement("log4net:event");
// Write out core trace event attributes.
xmlWriter.WriteAttributeString("logger", logger);
xmlWriter.WriteAttributeString("timestamp", timestamp.ToLocalTime().ToString("yyyy-MM-ddTHH:mm:ss.ffffffzzzz"));
xmlWriter.WriteAttributeString("level", GetLevelFromType(level));
xmlWriter.WriteAttributeString("thread", GetCurrentThread());
xmlWriter.WriteAttributeString("domain", domain);
// Only capture username if required (slow).
if (captureIdentity)
{
xmlWriter.WriteAttributeString("username", GetCurrentUsername());
}
// Write child elements.
WriteMessage(xmlWriter, message);
WriteProperties(xmlWriter, machineName);
// Close the trace event element.
xmlWriter.WriteEndElement();
}
messageWriter.Write(xml.ToString());
}
public static LogLevel ToLogLevel(this TraceEventType?traceEventType)
{
if (traceEventType != null && eventTypeLevels.TryGetValue(traceEventType.Value, out var value))
{
return(value);
}
return(LogLevel.None);
}
public void ThrowOnTraceEventType(TraceEventType?traceEventType)
{
TestTraceListener listener = Listener;
if (listener != null)
{
listener.ThrowTraceEventType = traceEventType;
}
}
public void ThrowOnTraceEventType(TraceEventType?traceEventType)
{
TestTraceListener listener = Trace.Listeners.OfType <TestTraceListener>()
.FirstOrDefault(x => x.TestId == TestContext.CurrentContext.Test.ID);
if (listener != null)
{
listener.ThrowTraceEventType = traceEventType;
}
}
public static int CountRows(DateTime fromDate, DateTime?toDate, TraceEventType?type, string appName)
{
using (ApplicationDataContext dataContext = new ApplicationDataContext())
{
var pred = CreatePredicate(dataContext, fromDate, toDate, type, appName);
return(dataContext.LogEntries
.Where(pred)
.Select(le => le.LogDate)
.Count());
}
}
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
lock (traceRequestMonitor)
{
tracedData = data;
tracedSource = source;
tracedEventType = eventType;
MockTraceListener.Entries.Add(data as LogEntry);
MockTraceListener.Instances.Add(this);
processedTraceRequests++;
}
}
public TraceEventArgs(TraceEventCache eventCache, string source, TraceEventType? eventType, string category, int? id, object message, object[] args, object[] data, Guid? relatedActivityId)
{
EventCache = eventCache;
Source = source;
EventType = eventType;
Category = category;
Id = id;
Format = message;
Args = args;
Data = data;
RelatedActivityId = relatedActivityId;
}
public TraceEventArgs(TraceEventCache eventCache, string source, TraceEventType?eventType, string category, int?id, object message, object[] args, object[] data, Guid?relatedActivityId)
{
EventCache = eventCache;
Source = source;
EventType = eventType;
Category = category;
Id = id;
Format = message;
Args = args;
Data = data;
RelatedActivityId = relatedActivityId;
}
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
lock (traceRequestMonitor)
{
this.tracedData = data;
this.tracedSource = source;
this.tracedEventType = eventType;
MockTraceListener.Entries.Add(data as LogEntry);
MockTraceListener.Instances.Add(this);
processedTraceRequests++;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TraceEventData"/>
/// class with the specified parameters.
/// </summary>
/// <param name="eventCache">
/// The <see cref="TraceEventCache"/> object.
/// </param>
/// <param name="source">The source of the event.</param>
/// <param name="eventType">The type of the event.</param>
/// <param name="id">The ID of the event.</param>
/// <param name="customerID">The ID of the Customer who was active on the moment of writing</param>
/// <param name="sessionID">The ID of the Session that was active on the moment of writing</param>
public TraceEventData(TraceEventCache eventCache, string source, TraceEventType?eventType, int id, Guid?customerID = null, string sessionID = null)
{
Cache = eventCache;
if (string.IsNullOrEmpty(source))
{
source = GetCallingSource();
}
Source = source;
Type = eventType;
ID = id;
CustomerID = customerID;
SessionID = sessionID;
}
/// <summary>
/// Overrides the <paramref name="configurationObject"/>'s properties with the Group Policy values from the
/// registry.
/// </summary>
/// <param name="configurationObject">The configuration object for instances that must be managed.</param>
/// <param name="policyKey">The <see cref="IRegistryKey"/> which holds the Group Policy overrides for the
/// configuration element.</param>
/// <remarks>Subclasses implementing this method must retrieve all the override values from the registry
/// before making modifications to the <paramref name="configurationObject"/> so any error retrieving
/// the override values will cancel policy processing.</remarks>
protected override void OverrideWithGroupPolicies(LoggingExceptionHandlerData configurationObject, IRegistryKey policyKey)
{
int? eventIdOverride = policyKey.GetIntValue(EventIdPropertyName);
Type formatterTypeOverride = policyKey.GetTypeValue(FormatterTypePropertyName);
String logCategoryOverride = policyKey.GetStringValue(LogCategoryPropertyName);
int? priorityOverride = policyKey.GetIntValue(PriorityPropertyName);
TraceEventType?severityOverride = policyKey.GetEnumValue <TraceEventType>(SeverityPropertyName);
String titleOverride = policyKey.GetStringValue(TitlePropertyName);
configurationObject.EventId = eventIdOverride.Value;
configurationObject.FormatterType = formatterTypeOverride;
configurationObject.LogCategory = logCategoryOverride;
configurationObject.Priority = priorityOverride.Value;
configurationObject.Severity = severityOverride.Value;
configurationObject.Title = titleOverride;
}
// Protected implementation of Dispose pattern.
protected virtual void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
TraceEventType?type = _hasError ? TraceEventType.Error : (TraceEventType?)null;
foreach (TraceInfo info in _traceInfos)
{
Trace.TraceEvent(type.HasValue ? type.Value : info.Type, info.EventId, _traceContext.ToString() + " " + info.Format, info.Args);
}
}
disposed = true;
}
/// <summary>
/// Reads the LogEntry objects as requested
/// Makes dummy calls to Application and LogType properties to allow accessing them without the source data context object
/// </summary>
/// <param name="startRow">Zero based start row number</param>
/// <param name="pageSize">Page size</param>
/// <returns>The found LogEntry objects</returns>
public static List <LogEntry> LoadByPage(DateTime fromDate, DateTime?toDate, TraceEventType?type, string appName, int startRow, int pageSize)
{
using (ApplicationDataContext dataContext = new ApplicationDataContext())
{
var loadOptions = new DataLoadOptions();
loadOptions.LoadWith <LogEntry>(le => le.LogType);
loadOptions.LoadWith <LogEntry>(le => le.Application);
dataContext.LoadOptions = loadOptions;
var pred = CreatePredicate(dataContext, fromDate, toDate, type, appName);
// Read records
var ret = dataContext.LogEntries
.Where(pred)
.OrderByDescending(le => le.LogDate)
.Skip(startRow)
.Take(pageSize)
.ToList();
return(ret);
}
}
/// <summary>
/// Get the <see cref="String"/> logging level based on the <see cref="TraceEventType"/>.
/// </summary>
/// <param name="eventType">The trace event type to capture.</param>
private static String GetLevelFromType(TraceEventType?eventType)
{
if (!eventType.HasValue)
{
return("TRACE");
}
switch (eventType)
{
case TraceEventType.Critical: return("FATAL");
case TraceEventType.Error: return("ERROR");
case TraceEventType.Warning: return("WARN");
case TraceEventType.Information: return("INFO");
case TraceEventType.Verbose: return("DEBUG");
default: return("TRACE");
}
}
private void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
public static System.Linq.Expressions.Expression <Func <LogEntry, bool> > CreatePredicate(ApplicationDataContext dataContext, DateTime fromDate, DateTime?toDate, TraceEventType?type, string appName)
{
var pred = CprBroker.Utilities.PredicateBuilder.True <LogEntry>();
if (toDate.HasValue && toDate.Value < fromDate)
{
var tmp = fromDate;
fromDate = toDate.Value;
toDate = tmp;
}
// By date
pred = pred.And(le => le.LogDate >= fromDate);
if (toDate.HasValue)
{
pred = pred.And(le => le.LogDate < toDate.Value.AddDays(1));
}
// Byte type
if (type.HasValue)
{
pred = pred.And(le => le.LogTypeId == (int)type.Value);
}
// By app
if (!string.IsNullOrEmpty(appName))
{
var appId = dataContext.Applications.Where(app => app.Name == appName).Select(app => app.ApplicationId).FirstOrDefault();
pred = pred.And(le => le.ApplicationId == appId);
}
return(pred);
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
StackTrace stackTrace = AutoLoggerName ? new StackTrace() : null;
ILogger logger = GetLogger(loggerName, stackTrace, out int userFrameIndex);
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = logger.Name;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
loggerName = (loggerName ?? Name) ?? string.Empty;
StackTrace stackTrace = null;
int userFrameIndex = -1;
if (AutoLoggerName)
{
stackTrace = new StackTrace();
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
var frame = stackTrace.GetFrame(i);
loggerName = Internal.StackTraceUsageUtils.LookupClassNameFromStackFrame(frame);
if (!string.IsNullOrEmpty(loggerName))
{
userFrameIndex = i;
break;
}
}
}
ILogger logger;
if (LogFactory != null)
{
logger = LogFactory.GetLogger(loggerName);
}
else
{
logger = LogManager.GetLogger(loggerName);
}
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = loggerName;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
loggerName = (loggerName ?? Name) ?? string.Empty;
StackTrace stackTrace = null;
int userFrameIndex = -1;
if (AutoLoggerName)
{
stackTrace = new StackTrace();
MethodBase userMethod = null;
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
var frame = stackTrace.GetFrame(i);
var method = frame.GetMethod();
if (method.DeclaringType == GetType())
{
// skip all methods of this type
continue;
}
if (method.DeclaringType != null && method.DeclaringType.Assembly == systemAssembly)
{
// skip all methods from System.dll
continue;
}
userFrameIndex = i;
userMethod = method;
break;
}
if (userFrameIndex >= 0)
{
if (userMethod != null && userMethod.DeclaringType != null)
{
loggerName = userMethod.DeclaringType.FullName;
}
}
}
ILogger logger;
if (LogFactory != null)
{
logger = LogFactory.GetLogger(loggerName);
}
else
{
logger = LogManager.GetLogger(loggerName);
}
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = loggerName;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
