public override void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) =>
{
_target.WriteVerbose(string.Format(m, f) + Environment.NewLine + e.ToString());
});
}
string formatMessage(ILogToken lt, int?hash, string level, string msg, object[] fmt, Exception eError)
{
int cnt = fmt.Length;
int size = 4;
if (eError != null)
{
size += 1;
}
StringBuilder newMsg = new StringBuilder(msg.Length + size * 4);
newMsg.Append("{");
newMsg.Append(cnt++);
newMsg.Append("}-{");
newMsg.Append(cnt++);
newMsg.Append("}-{");
newMsg.Append(cnt++);
newMsg.Append("}-({");
newMsg.Append(cnt++);
newMsg.Append("}): ");
newMsg.Append(msg);
if (eError != null)
{
newMsg.AppendLine();
newMsg.Append(" ");
newMsg.Append("{");
newMsg.Append(cnt++);
newMsg.Append("}");
}
return(newMsg.ToString());
}
public override void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) =>
{
_target.WriteError(new ErrorRecord(new Exception(string.Format(m, f), e), t.Symbol + "(" + u + ")", ErrorCategory.NotSpecified, null));
});
}
public static void Write(this ILogStream log, ILogToken token, Action <LogFormatMessageWithCustomUniqueness> msgBuilder)
{
log.Write(token, mo => {
msgBuilder((u, m, f) => {
mo(null, u, m, f);
});
});
}
public override void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) =>
{
_target.WriteInformation(string.Format(m, f), new[] { "uniquenessCode(" + u + ")" });
_target.WriteInformation(e, null);
});
}
public static void Write(this ILogStream log, ILogToken token, Action <LogException> msgBuilder)
{
log.Write(token, mo => {
msgBuilder((e) => {
mo(e, LogManager.GenerateUniquenessCode(e), null, null);
});
});
}
public static void Write(this ILogStream log, ILogToken token, Action <LogExceptionUniqueness> msgBuilder)
{
log.Write(token, mo => {
msgBuilder((e, u) => {
mo(e, u, null, null);
});
});
}
public static void Write(this ILogStream log, ILogToken token, Action <LogFormatMessage> msgBuilder)
{
log.Write(token, mo => {
msgBuilder((m, f) => {
mo(null, LogManager.GenerateUniquenessCode(m, f), m, f);
});
});
}
public bool Equals(ILogToken other)
{
if (other == null)
{
return(false);
}
return(this.Name == other.Name);
}
static Func <ILogStream, IUnstoppablePerformanceEvent> genTestCase(Func <ILogStream, ILogToken, IUnstoppablePerformanceEvent> func, ILogToken t, LoggingLevel level)
{
Func <ILogStream, IUnstoppablePerformanceEvent> result = (l) => func(l, t);
_tokenToAssert[result] = t;
_levelToAssert[result] = level;
return(result);
}
public bool IsWriteEnabled(ILogToken lt)
{
foreach (var filter in _filters)
{
if (!filter.IsWriteEnabled(lt))
{
return(false);
}
}
return(true);
}
public bool IsCounterEnabled(INamedCounterToken ct, ILogToken lt)
{
foreach (var filter in _filters)
{
if (!filter.IsCounterEnabled(ct, lt))
{
return(false);
}
}
return(true);
}
public void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) => {
if (m != null)
{
System.Diagnostics.Trace.WriteLine(string.Format(m, f));
}
if (e != null)
{
System.Diagnostics.Trace.WriteLine(e.ToString());
}
});
}
public void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) => {
if (m != null)
{
_stream.WriteLine(m, f);
}
if (e != null)
{
_stream.WriteLine(e.ToString());
}
});
}
public LogScope(
IEnumerable <ILogStream> streams,
ILogToken lt,
List <KeyValuePair <string, object> > contextData)
{
foreach (var log in streams)
{
// provide loggers chance to attach data if needed
log.OnAttachScopeParameters(lt, contextData);
}
// push context data
_context = LoggingCallContextStore.Push(contextData);
_streams = streams;
_lt = lt;
_contextData = contextData;
}
public override void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
try
{
_inner.Write(t, msgBuilder);
}
catch (Exception eError)
{
try
{
HandleError(this, eError);
}
catch (Exception eError2)
{
LastResort(this, eError, eError2);
}
}
}
public override void OnAttachScopeParameters(ILogToken lt, List <KeyValuePair <string, object> > parameters)
{
try
{
_inner.OnAttachScopeParameters(lt, parameters);
}
catch (Exception eError)
{
try
{
HandleError(this, eError);
}
catch (Exception eError2)
{
LastResort(this, eError, eError2);
}
}
}
/// <summary>
/// Executes for each performance event and executes some of the 'configuration' associated with events.
/// </summary>
private static IUnstoppablePerformanceEvent CreateEvent(ILogStream log, ILogToken token, LoggingLevel level, Func <InternalData, IUnstoppablePerformanceEvent> eventFunc)
{
var data = GetData(log);
var @event = eventFunc(data);
for (int i = 0, n = data.DefaultCompletionBehaviors.Count; i < n; i++)
{
var li = i;
@event.WhenComplete(e => data.DefaultCompletionBehaviors[li](e, log, token, level));
}
var initBehv = data.DefaultInitializationBehaviors;
var len = initBehv.Count;
for (int i = 0; i < len; i++)
{
initBehv[i](@event, log, token, level);
}
return(@event);
}
object[] formatArgs(ILogToken lt, int?hash, string level, string msg, object[] fmt, Exception eError)
{
int cnt = fmt.Length;
int exc = 0;
if (eError != null)
{
exc = 1;
}
Array.Resize(ref fmt, fmt.Length + 4 + exc);
fmt[cnt++] = DateTime.Now;
fmt[cnt++] = level;
fmt[cnt++] = lt.Name;
fmt[cnt++] = hash ?? 0;
if (eError != null)
{
fmt[cnt++] = eError;
}
return(fmt);
}
public override void OnDetachScopeParameters(ILogToken lt, List <KeyValuePair <string, object> > parameters)
{
_inner.OnDetachScopeParameters(lt, parameters);
_onDetach(lt, parameters);
}
public void Test(ILogToken token, Exception error, int?uniqueness, string message, object[] fmt)
{
_message(token, error, uniqueness, message, fmt);
}
public void OnDetachScopeParameters(ILogToken lt, List <KeyValuePair <string, object> > parameters)
{
// the current implementation at least, calls this method constantly to facilitate proper
// buffering of context data which would make assertions for these methods unrealistic
}
public void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) => Test(t, e, u, m, f));
}
public virtual void OnDetachScopeParameters(ILogToken lt, List <KeyValuePair <string, object> > parameters)
{
_inner.OnDetachScopeParameters(lt, parameters);
}
public virtual void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
_inner.Write(t, msgBuilder);
}
public override void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) => _inner.Write(t, log => log(e, u ?? LogManager.GenerateUniquenessCode(e, m), m, f)));
}
public override void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) => _inner.Write(t, z => z(e, u, fixMessage(m, f), fixFormat(m, f))));
}
public override void Write(ILogToken t, Action <CompleteLogMessage> msgBuilder)
{
msgBuilder((e, u, m, f) => _inner.Write(t, g => g(FormatException(e), u, m, f)));
}
public static void IncrementCounterBy(this ILogStream log, ILogToken lt, INamedCounterToken ct, Startwatch value)
{
log.IncrementCounterBy(lt, ct, value.ElapsedTicks);
}
public static void Warning(this IExpressiveLogs log, ILogToken token, Action <LogFormatMessage> msgBuilder)
{
LogManager.Warning.Write(token, msgBuilder);
}
