public static object GetFirstValue(this FormattedLogValues lv) { var field = lv.GetType().GetField("_values", BindingFlags.NonPublic | BindingFlags.Instance); var values = (object[])field.GetValue(lv); return(values?.FirstOrDefault()); }
public static string GetOriginalValue(this FormattedLogValues lv) { var field = lv.GetType().GetField("_originalMessage", BindingFlags.NonPublic | BindingFlags.Instance); var originalMessage = (string)field.GetValue(lv); return((string)lv.LastOrDefault().Value ?? originalMessage); }
public static Dictionary <string, object> GetLogMessageState(bool triggerAlert, string message, params object[] args) { Dictionary <string, object> messageState = new Dictionary <string, object>(); var aspnetcoreEnvironment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"); if (aspnetcoreEnvironment == EnvironmentName.Production || aspnetcoreEnvironment == EnvironmentName.Staging || aspnetcoreEnvironment == EnvironmentName.Development) { for (var index = 0; index < args.Length; index++) { object arg = args[index]; if (arg is string) { args[index] = SanitizeLogOutput.RedactSensitiveInfo(arg.ToString()); } } } string formattedLogValues = new FormattedLogValues(message, args).ToString(); messageState.Add("Message", formattedLogValues); messageState.Add("TriggerAlert", triggerAlert ? bool.TrueString.ToLower() : bool.FalseString.ToLower()); return(messageState); }
public void SetSimpleValueSuccessfully() { var original = new FormattedLogValues("The first number is {first} and the second is {second}", 10.ToString(), 20.ToString()); var updated = original.SetSimpleValue("Changed"); Assert.Equal("Changed", updated.ToString()); }
/// <summary> /// This method is called whenever claims about the user are requested (e.g. during token creation or via the userinfo endpoint) /// </summary> /// <param name="context">The context.</param> /// <returns></returns> public virtual Task GetProfileDataAsync(ProfileDataRequestContext context) { var logValues = new FormattedLogValues("Get profile called for subject {subject} from client {client} with claim types {claimTypes} via {caller}", context.Subject.GetSubjectId(), context.Client.ClientName ?? context.Client.ClientId, context.RequestedClaimTypes, context.Caller); Logger.LogDebug(logValues.ToString()); if (context.RequestedClaimTypes.Any()) { var user = Users.FindBySubjectId(context.Subject.GetSubjectId()); if (user != null) { context.AddFilteredClaims(user.Claims); } else { Logger.LogWarning("Users.FindBySubjectId returned null when " + logValues.ToString()); } } return(Task.FromResult(0)); }
public void UpdatesValuesSuccessfully() { var original = new FormattedLogValues("The first number is {first} and the second is {second}", 10.ToString(), 20.ToString()); var updated = original.SetValues(20.ToString(), 30.ToString()); Assert.Equal("The first number is 20 and the second is 30", updated.ToString()); }
public void GetsOriginalValueSuccessfully() { var original = new FormattedLogValues("The first number is {first} and the second is {second}", 10.ToString(), 20.ToString()); var originalValue = original.GetOriginalValue(); Assert.Equal("The first number is {first} and the second is {second}", originalValue); }
public void ClonesSimpleSuccessfully() { var original = new FormattedLogValues("Foo"); var cloned = original.Clone(); Assert.Equal(original.ToString(), cloned.ToString()); }
public void Log(Severity severity, LoggerType loggerType, string caller, string message, IPEndPoint myIPEndPoint, Exception exception, int eventCode = 0) { var logger = _loggerFactory.CreateLogger(caller); var formattedLogValues = new FormattedLogValues("{LoggerType} - {IPEndpoint}: {Message}", loggerType, myIPEndPoint, message); logger.Log(Map(severity), eventCode, formattedLogValues, exception, (state, ex) => state.ToString()); }
public void LogValues_With_UnbalancedBraces(string format) { Assert.Throws <FormatException>(() => { var logValues = new FormattedLogValues(format); logValues.Format(); }); }
public void ClonesComplexSuccessfully() { var original = new FormattedLogValues("The first number is {first} and the second is {second}", 10.ToString(), 20.ToString()); var cloned = original.Clone(); Assert.Equal(original.ToString(), cloned.ToString()); Assert.True(original.GetValues().SequenceEqual(cloned.GetValues())); }
public void LogValues_With_UnbalancedBraces(string format) { Assert.Throws <FormatException>(() => { var logValues = new FormattedLogValues(format, new object[] { "arg1" }); logValues.ToString(); }); }
public void LogValues_With_Basic_Types(string expected, string format, object[] args) { var logValues = new FormattedLogValues(format, args); Assert.Equal(expected, logValues.ToString()); // Original format is expected to be returned from GetValues. Assert.Equal(format, logValues.First(v => v.Key == "{OriginalFormat}").Value); }
public void LogValues_With_DateTime(string expected, string format) { var dateTime = new DateTime(2015, 1, 1, 1, 1, 1); var logValues = new FormattedLogValues(format, new object[] { dateTime, dateTime }); Assert.Equal(expected, logValues.ToString()); // Original format is expected to be returned from GetValues. Assert.Equal(format, logValues.First(v => v.Key == "{OriginalFormat}").Value); }
public static void LogStash(this ILogger logger, LogLevel level, EventId id, HttpContext context, Exception exception, string message, params object[] args) { if (message != null) { message = new FormattedLogValues(message, args).ToString(); } var logEntry = CreateLogEntry(context, id, exception, message, level); logger.Log <RedisLogEntry>(level, id, logEntry, exception, DefaultMessageFormatter); }
public static FormattedLogValues Clone(this FormattedLogValues original) { var field = original.GetType().GetField("_values", BindingFlags.NonPublic | BindingFlags.Instance); var values = (object[])field.GetValue(original); field = original.GetType().GetField("_originalMessage", BindingFlags.NonPublic | BindingFlags.Instance); var originalMessage = (string)field.GetValue(original); field = original.GetType().GetField("_formatter", BindingFlags.NonPublic | BindingFlags.Instance); var formatter = (LogValuesFormatter)field.GetValue(original); return(new FormattedLogValues(formatter?.OriginalFormat ?? originalMessage, values)); }
public void CachedFormattersAreCapped() { for (var i = 0; i < FormattedLogValues.MaxCachedFormatters; ++i) { var ignore = new FormattedLogValues($"{i}{{i}}", i); } // check cached formatter var formatter = new FormattedLogValues("0{i}", 0).Formatter; Assert.Same(formatter, new FormattedLogValues("0{i}", 0).Formatter); // check non-cached formatter formatter = new FormattedLogValues("test {}", 0).Formatter; Assert.NotSame(formatter, new FormattedLogValues("test {}", 0).Formatter); }
public FormattedLogValuesCollection(string format, object[] formatValues, IReadOnlyDictionary <string, object> additionalValues) { if (formatValues != null) { _formatter = new FormattedLogValues(format, formatValues); } else { _formatter = new FormattedLogValues(format); } _additionalValues = additionalValues?.ToList(); if (_additionalValues == null) { _additionalValues = new List <KeyValuePair <string, object> >(); } }
public void TestLoggerLogsAllTheIndividualParamsForStructuredDataUsingFormattedLogValuesWithDuplicateParameterNames() { LogEntry loggedEntry = null; A.CallTo(() => fakeEventHubLog.Log(A <LogEntry> .Ignored)).Invokes((LogEntry l) => loggedEntry = l); var eventHubLogger = CreateTestEventHubLogger(LogLevel.Information, LogLevel.Information, "UKHO.TestClass", fakeEventHubLog); IEnumerable <KeyValuePair <string, object> > structuredData = new FormattedLogValues("Message with {Property1} and {Property1} and a escaped C# keyword name {@var}", "Value 1", "Value 2", "Var value"); eventHubLogger.Log(LogLevel.Information, 123, structuredData, null, (s, e) => string.Join(",", s.Select(kv => $"{kv.Key}:{kv.Value}"))); CollectionAssert.DoesNotContain(loggedEntry.LogProperties.Keys, "MessageTemplate"); CollectionAssert.Contains(loggedEntry.LogProperties.Keys, "Property1"); CollectionAssert.AreEqual(new[] { "Value 1", "Value 2" }.ToList(), loggedEntry.LogProperties["Property1"] as IEnumerable); Assert.AreEqual("Var value", loggedEntry.LogProperties["var"]); Assert.AreEqual("Message with {Property1} and {Property1} and a escaped C# keyword name {@var}", loggedEntry.MessageTemplate); }
public bool IsCompatibleWith(string site, ClientVersion version) { if (requiredVersion.IsCompatibleWith(version)) { return(true); } if (logger.IsEnabled(notificationsLevel)) { lock (notificationsLock) { if (notifiedSites.Add(site)) { var log = new FormattedLogValues("Incompatibility with site \"{0}\". Site version: {1}, required version: {2}", site, version, requiredVersion); logger.Log(notificationsLevel, 0, log, null, (t, e) => t.ToString()); } } } return(false); }
public void Log(LogEvent @event) { if (@event is null) { return; } if (!IsEnabledFor(@event.Level)) { return; } var logLevel = ConvertLogLevel(@event.Level); var message = settings.UseVostokTemplate ? LogEventFormatter.Format(@event, Template) : LogMessageFormatter.Format(@event); var state = new FormattedLogValues(message, Array.Empty <object>()); logger.Log(logLevel, NullEventId, state, @event.Exception, MessageFormatter); }
public void LogValues_WithNullAndEnumerable_IsNotMutatingParameter() { string format = "TestMessage {Param1} {Param2} {Param3} {Param4}"; int param1 = 1; string param2 = null; int[] param3 = new[] { 1, 2, 3, 4 }; string param4 = "string"; var logValues = new FormattedLogValues(format, param1, param2, param3, param4); logValues.ToString(); var state = logValues.ToArray(); Assert.Equal(new[] { new KeyValuePair <string, object>("Param1", param1), new KeyValuePair <string, object>("Param2", param2), new KeyValuePair <string, object>("Param3", param3), new KeyValuePair <string, object>("Param4", param4), new KeyValuePair <string, object>("{OriginalFormat}", format), }, state); }
private static bool messageMatches(string expectedMessage, FormattedLogValues formattedLogValues) { // separate method as opposed to lambda for easier debugging return(formattedLogValues.ToString() == expectedMessage); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { var message = new FormattedLogValues(formatter.Invoke(state, exception)); _testOutputHelper.WriteLine($"{logLevel} - {eventId} - {message}"); }
public void LogValues_WithNulls(string expected, string format, object[] args) { var logValues = new FormattedLogValues(format, args); Assert.Equal(expected, logValues.ToString()); }
public void FormatsEnumerableValues(string messageFormat, object[] arguments, string expected) { var logValues = new FormattedLogValues(messageFormat, arguments); Assert.Equal(expected, logValues.ToString()); }
public static object[] GetValues(this FormattedLogValues lv) { var field = lv.GetType().GetField("_values", BindingFlags.NonPublic | BindingFlags.Instance); return((object[])field.GetValue(lv)); }
/// <summary> Replaces the values in the FormattedLogValues instance.</summary> /// <param name="lv">The FormattedLogValues instance.</param> /// <param name="values">The values.</param> /// <returns></returns> public static FormattedLogValues SetValues(this FormattedLogValues lv, params object[] values) { return(new FormattedLogValues(lv.GetOriginalValue(), values)); }
private static string FormatMessage(FormattedLogValues state, Exception error) { return(state.ToString()); }
/// <summary>Sets a simple value.</summary> /// <param name="original">The original.</param> /// <param name="value">The value.</param> /// <returns></returns> public static FormattedLogValues SetSimpleValue(this FormattedLogValues original, string value) { return(new FormattedLogValues(value)); }