/// <summary>
/// Append log.
/// </summary>
/// <param name="loggingEvent">The event.</param>
protected override void Append(LoggingEvent loggingEvent)
{
if (loggingEvent == null)
{
return;
}
if (!Hub.IsEnabled && _sdkHandle == null)
{
if (Dsn == null)
{
return;
}
lock (_initSync)
{
if (_sdkHandle == null)
{
_sdkHandle = _initAction(Dsn);
Debug.Assert(_sdkHandle != null);
}
}
}
var exception = loggingEvent.ExceptionObject ?? loggingEvent.MessageObject as Exception;
var evt = new SentryEvent(exception)
{
Sdk =
{
Name = Constants.SdkName,
Version = NameAndVersion.Version
},
Logger = loggingEvent.LoggerName,
Level = loggingEvent.ToSentryLevel()
};
evt.Sdk.AddPackage(ProtocolPackageName, NameAndVersion.Version);
if (!string.IsNullOrWhiteSpace(loggingEvent.RenderedMessage))
{
evt.Message = loggingEvent.RenderedMessage;
}
evt.SetExtras(GetLoggingEventProperties(loggingEvent));
if (SendIdentity && !string.IsNullOrEmpty(loggingEvent.Identity))
{
evt.User = new User
{
Id = loggingEvent.Identity
};
}
if (!string.IsNullOrWhiteSpace(Environment))
{
evt.Environment = Environment;
}
_ = Hub.CaptureEvent(evt);
}
public static SentryEvent CleanseEvent(SentryEvent sentryEvent)
{
try
{
sentryEvent.Message.Message = CleanseLogMessage.Cleanse(sentryEvent.Message.Message);
if (sentryEvent.Fingerprint != null)
{
var fingerprint = sentryEvent.Fingerprint.Select(x => CleanseLogMessage.Cleanse(x)).ToList();
sentryEvent.SetFingerprint(fingerprint);
}
if (sentryEvent.Extra != null)
{
var extras = sentryEvent.Extra.ToDictionary(x => x.Key, y => (object)CleanseLogMessage.Cleanse((string)y.Value));
sentryEvent.SetExtras(extras);
}
foreach (var exception in sentryEvent.SentryExceptions)
{
exception.Value = CleanseLogMessage.Cleanse(exception.Value);
foreach (var frame in exception.Stacktrace.Frames)
{
frame.FileName = ShortenPath(frame.FileName);
}
}
}
catch (Exception)
{
}
return(sentryEvent);
}
protected override void Write(LogEventInfo logEvent)
{
if (_unauthorized || !SentryEnabled)
{
return;
}
try
{
SentrySdk.AddBreadcrumb(logEvent.FormattedMessage, logEvent.LoggerName, level: BreadcrumbLevelMap[logEvent.Level]);
// don't report non-critical events without exceptions
if (!IsSentryMessage(logEvent))
{
return;
}
var fingerPrint = GetFingerPrint(logEvent);
if (!_debounce.Allowed(fingerPrint))
{
return;
}
var extras = logEvent.Properties.ToDictionary(x => x.Key.ToString(), x => (object)x.Value.ToString());
extras.Remove("Sentry");
if (logEvent.Exception != null)
{
foreach (DictionaryEntry data in logEvent.Exception.Data)
{
extras.Add(data.Key.ToString(), data.Value.ToString());
}
}
var sentryEvent = new SentryEvent(logEvent.Exception)
{
Level = LoggingLevelMap[logEvent.Level],
Logger = logEvent.LoggerName,
Message = logEvent.FormattedMessage
};
sentryEvent.SetExtras(extras);
sentryEvent.SetFingerprint(fingerPrint);
SentrySdk.CaptureEvent(sentryEvent);
}
catch (Exception e)
{
OnError(e);
}
}
public void Emit(LogEvent logEvent)
{
string?context = null;
if (logEvent.Properties.TryGetValue("SourceContext", out var prop) &&
prop is ScalarValue scalar &&
scalar.Value is string sourceContextValue)
{
if (sourceContextValue.StartsWith("Sentry.") ||
string.Equals(sourceContextValue, "Sentry", StringComparison.Ordinal))
{
return;
}
context = sourceContextValue;
}
var hub = _hubAccessor();
if (hub is null || !hub.IsEnabled)
{
return;
}
var exception = logEvent.Exception;
var template = logEvent.MessageTemplate.Text;
var formatted = FormatLogEvent(logEvent);
if (logEvent.Level >= _options.MinimumEventLevel)
{
var evt = new SentryEvent(exception)
{
Logger = context,
Message = new SentryMessage
{
Formatted = formatted,
Message = template
},
Level = logEvent.Level.ToSentryLevel()
};
if (evt.Sdk is { } sdk)
{
sdk.Name = Constants.SdkName;
sdk.Version = NameAndVersion.Version;
if (NameAndVersion.Version is { } version)
{
sdk.AddPackage(ProtocolPackageName, version);
}
}
evt.SetExtras(GetLoggingEventProperties(logEvent));
_ = hub.CaptureEvent(evt);
}
// Even if it was sent as event, add breadcrumb so next event includes it
if (logEvent.Level >= _options.MinimumBreadcrumbLevel)
{
Dictionary <string, string>?data = null;
if (exception != null && !string.IsNullOrWhiteSpace(formatted))
{
// Exception.Message won't be used as Breadcrumb message
// Avoid losing it by adding as data:
data = new Dictionary <string, string>
{
{ "exception_message", exception.Message }
};
}
hub.AddBreadcrumb(
_clock,
string.IsNullOrWhiteSpace(formatted)
? exception?.Message ?? ""
: formatted,
context,
data: data,
level: logEvent.Level.ToBreadcrumbLevel());
}
}
/// <summary>
/// Append log.
/// </summary>
/// <param name="loggingEvent">The event.</param>
protected override void Append(LoggingEvent loggingEvent)
{
// Not to throw on code that ignores nullability warnings.
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (loggingEvent is null)
{
return;
}
if (!Hub.IsEnabled && _sdkHandle == null)
{
if (Dsn == null)
{
return;
}
lock (_initSync)
{
if (_sdkHandle == null)
{
_sdkHandle = _initAction(Dsn);
Debug.Assert(_sdkHandle != null);
}
}
}
var exception = loggingEvent.ExceptionObject ?? loggingEvent.MessageObject as Exception;
var evt = new SentryEvent(exception)
{
Logger = loggingEvent.LoggerName,
Level = loggingEvent.ToSentryLevel()
};
if (evt.Sdk is {} sdk)
{
sdk.Name = Constants.SdkName;
sdk.Version = NameAndVersion.Version;
if (NameAndVersion.Version is {} version)
{
sdk.AddPackage(ProtocolPackageName, version);
}
}
if (!string.IsNullOrWhiteSpace(loggingEvent.RenderedMessage))
{
evt.Message = loggingEvent.RenderedMessage;
}
evt.SetExtras(GetLoggingEventProperties(loggingEvent));
if (SendIdentity && !string.IsNullOrEmpty(loggingEvent.Identity))
{
evt.User = new User
{
Id = loggingEvent.Identity
};
}
if (!string.IsNullOrWhiteSpace(Environment))
{
evt.Environment = Environment;
}
_ = Hub.CaptureEvent(evt);
}
/// <summary>
/// Append log.
/// </summary>
/// <param name="loggingEvent">The event.</param>
protected override void Append(LoggingEvent loggingEvent)
{
if (loggingEvent == null)
{
return;
}
if (!Hub.IsEnabled && _sdkHandle == null)
{
if (Dsn == null)
{
return;
}
lock (_initSync)
{
if (_sdkHandle == null)
{
_sdkHandle = _initAction(Dsn);
Debug.Assert(_sdkHandle != null);
}
}
}
// Either log a BreadCrumb or an Event
if (MinimumBreadcrumbLevel < loggingEvent.Level)
{
var exception = loggingEvent.ExceptionObject ?? loggingEvent.MessageObject as Exception;
var evt = new SentryEvent(exception)
{
Sdk =
{
Name = Constants.SdkName,
Version = NameAndVersion.Version
},
Logger = loggingEvent.LoggerName,
Level = loggingEvent.ToSentryLevel()
};
evt.Sdk.AddPackage(ProtocolPackageName, NameAndVersion.Version ?? string.Empty);
if (!string.IsNullOrWhiteSpace(loggingEvent.RenderedMessage))
{
evt.Message = loggingEvent.RenderedMessage;
}
evt.SetExtras(GetLoggingEventProperties(loggingEvent));
if (SendIdentity && !string.IsNullOrEmpty(loggingEvent.Identity))
{
evt.User = new User
{
Id = loggingEvent.Identity
};
}
if (!string.IsNullOrWhiteSpace(Environment))
{
evt.Environment = Environment;
}
Hub.CaptureEvent(evt);
}
else
{
string message = !string.IsNullOrWhiteSpace(loggingEvent.RenderedMessage) ? loggingEvent.RenderedMessage : "";
string type = "";
string category = loggingEvent.LoggerName;
BreadcrumbLevel level = loggingEvent.ToBreadcrumbLevel();
IDictionary <string, string> data = GetLoggingEventProperties(loggingEvent).ToDictionary(x => x.Key, x => x.Value.ToString());
Hub.AddBreadcrumb(message, category, type, data, level);
}
}
public void Emit(LogEvent logEvent)
{
if (logEvent == null ||
logEvent.Properties.TryGetValue("SourceContext", out var prop) &&
prop is ScalarValue scalar &&
scalar.Value is string context &&
(context.StartsWith("Sentry.") ||
string.Equals(context, "Sentry", StringComparison.Ordinal)))
{
return;
}
var hub = _hubAccessor();
if (hub == null || !hub.IsEnabled)
{
return;
}
var exception = logEvent.Exception;
var formatted = logEvent.RenderMessage(_options.FormatProvider);
var template = logEvent.MessageTemplate.Text;
if (logEvent.Level >= _options.MinimumEventLevel)
{
var evt = new SentryEvent(exception)
{
Sdk =
{
Name = Constants.SdkName,
Version = NameAndVersion.Version
},
Message = null,
LogEntry = new LogEntry
{
Formatted = formatted,
Message = template
},
Level = logEvent.Level.ToSentryLevel()
};
evt.Sdk.AddPackage(ProtocolPackageName, NameAndVersion.Version);
evt.SetExtras(GetLoggingEventProperties(logEvent));
hub.CaptureEvent(evt);
}
// Even if it was sent as event, add breadcrumb so next event includes it
if (logEvent.Level >= _options.MinimumBreadcrumbLevel)
{
Dictionary <string, string> data = null;
if (exception != null && !string.IsNullOrWhiteSpace(formatted))
{
// Exception.Message won't be used as Breadcrumb message
// Avoid losing it by adding as data:
data = new Dictionary <string, string>
{
{ "exception_message", exception.Message }
};
}
hub.AddBreadcrumb(
_clock,
message: string.IsNullOrWhiteSpace(formatted)
? exception?.Message
: formatted,
data: data,
level: logEvent.Level.ToBreadcrumbLevel());
}
}
