/// <summary>
/// Override this method to catch the event when a command is about to be executed.
/// </summary>
/// <param name="command">Command being executed</param>
protected override void OnCommandExecuting(SqlCommand command)
{
if (command == null)
{
return;
}
var sb = new StringBuilder();
if (command.Connection != null)
{
sb.AppendFormat("Connection: {0}\r\n", command.Connection.ConnectionString);
}
sb.AppendFormat("{0}\r\n", command.CommandText);
foreach (SqlParameter par in command.Parameters)
{
sb.AppendFormat(" {0} ({1}): <'{2}'>\r\n", par.ParameterName, par.SqlDbType, par.Value);
}
var logItem = new TraceLogItem
{
OperationType = "SQLCommand",
Type = TraceLogItemType.Informational,
Message = sb.ToString()
};
Tracer.Log(logItem);
}
/// <summary>
/// Naplózza az adott bejegyzést
/// </summary>
/// <param name="item">Naplóbejegyzés</param>
public static void Log(TraceLogItem item)
{
try
{
if (LoggerInstance == null || (int)item.Type < (int)s_LogType)
{
return;
}
// --- Az üzenetben lévő sorvégeket lecseréljük
if (item.Message != null)
{
item.Message = item.Message.Replace("\r\n", "\n");
item.Message = item.Message.Replace("\n", "\r\n\t\t\t\t\t");
}
if (item.DetailedMessage != null)
{
item.DetailedMessage = item.DetailedMessage.Replace("\r\n", "\n");
item.DetailedMessage = item.DetailedMessage.Replace("\n", "\r\n\t\t\t\t\t\t");
}
// --- Naplózzuk az üzenetet
LoggerInstance.Log(item);
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
// --- A naplózásban levő kivételt lenyeljük
}
}
/// <summary>
/// Log the specified message to the secondary event log
/// </summary>
/// <param name="eventClass">Event parameters</param>
/// <param name="finalMessage">Message to log</param>
private static void LogToSecondary(LogEventBase eventClass, string finalMessage)
{
var itemType = TraceLogItemType.Informational;
switch (eventClass.Type)
{
case EventLogEntryType.FailureAudit:
case EventLogEntryType.Error:
itemType = TraceLogItemType.Error;
break;
case EventLogEntryType.Warning:
itemType = TraceLogItemType.Warning;
break;
case EventLogEntryType.SuccessAudit:
itemType = TraceLogItemType.Success;
break;
}
var logItem = new TraceLogItem
{
Message = finalMessage,
DetailedMessage = String.Format("EventId: {0}, CategoryId: {1}",
eventClass.EventId, eventClass.CategoryId),
OperationType = "Windows Event Trace",
Type = itemType
};
TraceLogger.Log(logItem);
}
/// <summary>
/// Override to specify how the trace entry should be logged.
/// </summary>
/// <param name="item">Trace entry</param>
protected override void DoLog(TraceLogItem item)
{
using (var db = new SqlDatabase(_sqlConnectionOrName))
{
var logRecord = new TraceRecord
{
// ReSharper disable PossibleInvalidOperationException
Timestamp = item.TimestampUtc.Value,
// ReSharper restore PossibleInvalidOperationException
Type = (int)item.Type,
OperationType = item.OperationType,
SessionId = item.SessionId,
BusinessTransactionId = item.BusinessTransactionId,
OperationInstanceId = item.OperationInstanceId,
TenantId = item.TenantId,
Message = item.Message,
DetailedMessage = item.DetailedMessage,
ServerName = item.ServerName,
// ReSharper disable PossibleInvalidOperationException
ThreadId = item.ThreadId.Value
// ReSharper restore PossibleInvalidOperationException
};
db.Insert(logRecord);
}
}
public void SingleScenarioWorks()
{
// --- Arrange
var tracer = new FileTraceLogger(LOG_FILE, LOG_ROOT, flushAfter: 3);
var traceItem = new TraceLogItem
{
TimestampUtc = new DateTime(2012, 1, 1, 8, 0, 0),
Type = TraceLogItemType.Informational,
ServerName = "Server",
ThreadId = 123,
OperationType = "TestOp",
Message = "Message"
};
// --- Act
for (var i = 0; i < 5; i++)
{
tracer.Log(traceItem);
}
tracer.Dispose();
// --- Assert
var text = File.ReadAllText(Path.Combine(LOG_ROOT, LOG_FILE));
var lines = text.Split(new [] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (var line in lines)
{
line.ShouldContain("Informational\tServer\t123\tTestOp\tMessage\t");
}
lines.ShouldHaveCountOf(5);
}
/// <summary>
/// This method is called before the body of the aspected method is about to be
/// invoked.
/// </summary>
/// <param name="args">Descriptor representing the method call</param>
/// <param name="result">Result descriptor coming from the previous aspect.</param>
/// <returns>
/// This method should return null value indicating that the aspected method's body should
/// be called. If the method body invocation should be omitted, this method returns the
/// result descriptor substituting the result coming from the invocation of the method body.
/// </returns>
public override IMethodResultDescriptor OnEntry(IMethodCallDescriptor args, IMethodResultDescriptor result)
{
if (args.Method.DeclaringType == typeof(IServiceObject))
{
return(null);
}
CallContext.LogicalSetData(START_TICK_LABEL, EnvironmentInfo.GetCurrentDateTimeUtc().Ticks);
var details = new StringBuilder();
var traceAttrs = args.Method.GetCustomAttributes(typeof(NoArgumentTraceAttribute), true);
if (traceAttrs.Length == 0)
{
for (var i = 0; i < args.ArgumentCount; i++)
{
var arg = args.GetArgument(i);
var argJson = JsonConvert.SerializeObject(arg.Value);
details.AppendFormat("{0}: {1}\r\n", arg.Name, argJson);
}
}
var logItem = new TraceLogItem
{
Type = TraceLogItemType.Informational,
OperationType = GetOperationName(args),
Message = "Enter",
DetailedMessage = details.ToString()
};
Tracer.Log(logItem);
return(null);
}
public void Log(TraceLogItemType type, string operationType, string message, string detailedMessage = null)
{
var item = new TraceLogItem
{
Type = type,
OperationType = operationType,
Message = message,
DetailedMessage = detailedMessage
};
Log(item);
}
public static void Log(TraceLogItemType type, string operationType, string message, string detailedMessage = null)
{
var item = new TraceLogItem
{
Type = type,
OperationType = operationType,
Message = message,
DetailedMessage = detailedMessage
};
Log(item);
}
/// <summary>
/// This method is called right after <see cref="IMethodAspect.OnExit"/>, when the method body
/// invocation raised an exception. Otherwise, the <see cref="IMethodAspect.OnSuccess"/> method is
/// called.
/// </summary>
/// <param name="args">Message representing the method call</param>
/// <param name="exceptionRaised">Exception raised by the method body</param>
/// <returns>Exception instance to be raised by the caller of the aspected method</returns>
public override Exception OnException(IMethodCallDescriptor args, Exception exceptionRaised)
{
if (args.Method.DeclaringType == typeof(IServiceObject))
{
return(null);
}
var logItem = new TraceLogItem
{
Type = TraceLogItemType.Error,
OperationType = GetOperationName(args),
Message = "Exception",
DetailedMessage = exceptionRaised.ToString()
};
Tracer.Log(logItem);
return(exceptionRaised);
}
/// <summary>
/// Raises the exception event.
/// </summary>
/// <param name="context">The context for the action.</param>
public override void OnException(HttpActionExecutedContext context)
{
// --- Log this information to the trace log
var logItem = new TraceLogItem
{
Type = TraceLogItemType.Error,
OperationType = "WebAPI",
Message = "Exception",
DetailedMessage = context.Exception.ToString()
};
Tracer.Log(logItem);
var businessEx = context.Exception as BusinessOperationException;
if (businessEx != null)
{
// --- This is a business issue
var info = new BusinessExceptionInfo
{
reasonCode = businessEx.ReasonCode,
isBusiness = true,
message = businessEx.Message,
errorObject = businessEx.Notifications.Items
};
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(JsonConvert.SerializeObject(info))
});
}
// --- This is an infrastructure issue
var infraInfo = new InfrastructureExceptionInfo
{
reasonCode = "Unexpected",
isBusiness = false,
message = context.Exception.Message
};
throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(JsonConvert.SerializeObject(infraInfo))
});
}
/// <summary>
/// This method is called right after <see cref="IMethodAspect.OnExit"/>, when the method body
/// invocation was successful. Otherwise, the <see cref="IMethodAspect.OnException"/> method is
/// called.
/// </summary>
/// <param name="args">Descriptor representing the method call</param>
/// <param name="result">Result descriptor representing the return values of the call</param>
/// <returns>
/// This method should return the value of <paramref name="result"/> by default, or it
/// can modify the original result on return that value.
/// </returns>
public override IMethodResultDescriptor OnSuccess(IMethodCallDescriptor args, IMethodResultDescriptor result)
{
if (args.Method.DeclaringType == typeof(IServiceObject))
{
return(null);
}
var startTimeData = CallContext.GetData(START_TICK_LABEL);
var timeSpan = startTimeData == null
? (TimeSpan?)null
: TimeSpan.FromTicks(EnvironmentInfo.GetCurrentDateTimeUtc().Ticks - (long)startTimeData);
var logItem = new TraceLogItem
{
Type = TraceLogItemType.Success,
OperationType = GetOperationName(args),
Message = "Exit",
DetailedMessage = string.Format("({0} ms)",
timeSpan.HasValue ? timeSpan.Value.Milliseconds.ToString(CultureInfo.InvariantCulture) : "??")
};
Tracer.Log(logItem);
return(result);
}
public void ComplexScenarioWorks()
{
// --- Arrange
if (File.Exists(Path.Combine(LOG_ROOT, "08", LOG_FILE)))
{
File.Delete(Path.Combine(LOG_ROOT, "08", LOG_FILE));
}
if (File.Exists(Path.Combine(LOG_ROOT, "09", LOG_FILE)))
{
File.Delete(Path.Combine(LOG_ROOT, "09", LOG_FILE));
}
var tracer = new FileTraceLogger(LOG_FILE, LOG_ROOT, "hh", flushAfter: 3);
var traceItem1 = new TraceLogItem
{
// 8 o'clock
TimestampUtc = new DateTime(2012, 1, 1, 8, 0, 0),
Type = TraceLogItemType.Informational,
ServerName = "Server",
ThreadId = 123,
OperationType = "TestOp",
Message = "Message"
};
var traceItem2 = new TraceLogItem
{
// 9 o'clock
TimestampUtc = new DateTime(2012, 1, 1, 9, 0, 0),
Type = TraceLogItemType.Informational,
ServerName = "Server",
ThreadId = 123,
OperationType = "TestOp",
Message = "Message"
};
// --- Act
for (var i = 0; i < 3; i++)
{
tracer.Log(traceItem1);
tracer.Log(traceItem2);
tracer.Log(traceItem1);
tracer.Log(traceItem1);
}
tracer.Dispose();
// --- Assert
var text1 = File.ReadAllText(Path.Combine(LOG_ROOT, "08", LOG_FILE));
var lines1 = text1.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
lines1.ShouldHaveCountOf(9);
foreach (var line in lines1)
{
line.ShouldContain("\tInformational\tServer\t123\tTestOp\tMessage\t");
}
var text2 = File.ReadAllText(Path.Combine(LOG_ROOT, "09", LOG_FILE));
var lines2 = text2.Split(new[] { "\r\n" }, StringSplitOptions.RemoveEmptyEntries);
lines2.ShouldHaveCountOf(3);
foreach (var line in lines2)
{
line.ShouldContain("\tInformational\tServer\t123\tTestOp\tMessage\t");
}
}
/// <summary> /// Override to specify how the trace entry should be logged. /// </summary> /// <param name="item">Trace entry</param> protected abstract void DoLog(TraceLogItem item);
/// <summary>
/// Logs the specified trace entry
/// </summary>
/// <param name="item">Trace entry</param>
public void Log(TraceLogItem item)
{
item.EnsureProperties();
DoLog(item);
}
/// <summary> /// Override to specify how the trace entry should be logged. /// </summary> /// <param name="item">Trace entry</param> protected abstract void DoLog(TraceLogItem item);
/// <summary>
/// Logs the specified trace entry
/// </summary>
/// <param name="item">Trace entry</param>
public void Log(TraceLogItem item)
{
item.EnsureProperties();
DoLog(item);
}
