public void Gaucho_Filter_PropertyFormatter_FromFilterFactory()
{
var converter = new EventDataConverter();
var filters = new List <string>
{
"Level -> lvl",
"Message",
"prop <- ${lvl}_error_${Message}"
};
foreach (var filter in filters)
{
converter.Add(FilterFactory.BuildFilter(filter));
}
var input = new LogMessage
{
Level = "Info",
Message = "The message",
Title = "title"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
var formatted = converter.Format("prop", data);
Assert.AreEqual(formatted, "Info_error_The message");
}
private async Task OnResponseCreated(string id, CancellationToken cancellationToken, Func <EventArgs> getEventData, Func <string, CancellationToken, Func <EventArgs>, Task> signal)
{
using (Extensions.NoSynchronizationContext)
{
var eventData = EventDataConverter.ConvertFrom(getEventData());
var response = eventData?.ResponseMessage as HttpResponseMessage;
if (response != null)
{
if (response.Headers.Warning != null && response.Headers.Warning.Any())
{
string warningHeader = response.Headers.Warning.ToString();
await signal(Events.Warning, cancellationToken,
() => EventFactory.CreateWarningEvent(warningHeader));
}
// Log request after response since all our request header are set via middleware pipeline.
var request = response?.RequestMessage;
if (request != null)
{
await signal(Events.Debug, cancellationToken,
() => EventFactory.CreateLogEvent(HttpMessageLogFormatter.GetHttpRequestLog(request)));
}
await signal(Events.Debug, cancellationToken,
() => EventFactory.CreateLogEvent(HttpMessageLogFormatter.GetHttpResponseLog(response)));
}
}
}
public void Formatter_NestedObject()
{
var converter = new EventDataConverter();
var filters = new List <string>
{
"Sub.Value -> sub.value",
"Message"
};
foreach (var filter in filters)
{
converter.Add(FilterFactory.BuildFilter(filter));
}
var input = new NestedLog
{
Sub = new SubClass
{
Value = "nested value"
},
Message = "The message"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
data.ToString().MatchSnapshot();
}
public void Gaucho_Filter_FromFilterFactory()
{
var converter = new EventDataConverter();
var filters = new List <string>
{
"Level -> dst_lvl",
"Message"
};
foreach (var filter in filters)
{
converter.Add(FilterFactory.BuildFilter(filter));
}
var input = new LogMessage
{
Level = "Info",
Message = "The message",
Title = "title"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
Assert.AreEqual(data.ToString(), "{\r\n dst_lvl -> Info\r\n Message -> The message\r\n}");
}
public void Gaucho_Filter_JsonFormatter_FromFilterFactory()
{
var converter = new EventDataConverter();
var filters = new List <string>
{
"Level -> dst_lvl",
"Message",
"json <- [dst_lvl,Message -> msg]"
};
foreach (var filter in filters)
{
converter.Add(FilterFactory.BuildFilter(filter));
}
var input = new LogMessage
{
Level = "Info",
Message = "The message",
Title = "title"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
var formatted = converter.Format("json", data);
Assert.AreEqual(formatted, "{\"dst_lvl\":\"Info\",\"msg\":\"The message\"}");
}
public void Gaucho_Filter_JsonFormatter()
{
var converter = new EventDataConverter
{
new PropertyFilter("Level", "dst_lvl"),
new PropertyFilter("Message"),
new JsonFilter(new List <PropertyFilter>
{
new PropertyFilter("dst_lvl"),
new PropertyFilter("Message", "msg")
})
};
var input = new LogMessage
{
Level = "Info",
Message = "The message",
Title = "title"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
var formatted = converter.Format("json", data);
Assert.AreEqual(formatted, "{\"dst_lvl\":\"Info\",\"msg\":\"The message\"}");
}
public void Gaucho_Filter_PropertyFormatter_UnknownFilter()
{
var converter = new EventDataConverter();
var filters = new List <string>
{
"Level -> lvl",
"Message",
"prop <- ${lvl}_error_${Message}"
};
foreach (var filter in filters)
{
converter.Add(FilterFactory.BuildFilter(filter));
}
var input = new LogMessage
{
Level = "Info",
Message = "The message",
Title = "title"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
var formatted = converter.Format("PROP", data);
Assert.That(formatted.Contains("lvl -> Info") && formatted.Contains("Message -> The message"));
}
public void Gaucho_Filter_ConvertDataMultipleTimes()
{
var converter = new EventDataConverter();
var filters = new List <string>
{
"Level -> dst_lvl",
"Message -> msg"
};
foreach (var filter in filters)
{
converter.Add(FilterFactory.BuildFilter(filter));
}
var input = new LogMessage
{
Level = "Info",
Message = "The message",
Title = "title"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
Assert.That(data.All(p => p.Key != "Message"));
// the property Message -> msg cannot be converted because only msg is in the datacollection
// still has to return the msg property if present
data = converter.Convert(data);
Assert.AreEqual(data.ToString(), "{\r\n dst_lvl -> Info\r\n msg -> The message\r\n}");
}
public JsonFilter(IEnumerable <PropertyFilter> filters)
{
_converter = new EventDataConverter();
foreach (var filter in filters)
{
_converter.Add(filter);
}
}
private async Task OnCmdletException(string id, CancellationToken cancellationToken, Func <EventArgs> getEventData, Func <string, CancellationToken, Func <EventArgs>, Task> signal, Exception exception)
{
using (Extensions.NoSynchronizationContext)
{
var eventData = EventDataConverter.ConvertFrom(getEventData());
await signal(Events.Debug, cancellationToken, () => EventFactory.CreateLogEvent($"[{id}]: Received exception with message '{eventData?.Message}'"));
}
}
/// <summary>
/// Handles the Finally event, which is called just after a response is received.
/// </summary>
/// <param name="id">The ID of the event</param>
/// <param name="cancellationToken">The cancellation token for the event</param>
/// <param name="getEventData">A delegate to get the detailed event data</param>
/// <param name="signal">The callback for the event dispatcher</param>
/// <returns>
/// A <see cref="global::System.Threading.Tasks.Task" /> that will be complete when handling of the event is completed.
/// </returns>
private async Task Finally(string id, CancellationToken cancellationToken, Func <EventArgs> getEventData, Func <string, CancellationToken, Func <EventArgs>, Task> signal)
{
using (Extensions.NoSynchronizationContext)
{
var eventData = EventDataConverter.ConvertFrom(getEventData());
using (var responseFormatter = new HttpMessageFormatter(eventData.ResponseMessage as HttpResponseMessage))
{
var responseString = await responseFormatter.ReadAsStringAsync();
await signal(Events.Debug, cancellationToken, () => EventFactory.CreateLogEvent(responseString));
}
}
}
public void TestFromEventData()
{
var subject = new EventDataConverter ();
var actual = subject.FromEventData (
new RawEvent (this.eventData.Type, this.eventData.Metadata, this.eventData.Data));
actual.Header.Should ().NotBeNull ();
actual.Header.EventId.Should ().Be (expectedEventId);
actual.Body.Should ().NotBeNull ();
actual.Body.EventType.Should ().Be<SimpleEvent> ();
actual.Body.EventData.Should ().Be ("{\"Name\":\"A simple event\"}");
}
/// <summary>
/// Print event details to the provided stream
/// </summary>
/// <param name="getEventData">The event data to print</param>
/// <param name="signal">The delegate for signaling events to the runtime</param>
/// <param name="token">The cancellation token for the request</param>
/// <param name="streamName">The name of the stream to print data to</param>
/// <param name="eventName">The name of the event to be printed</param>
public static async void Print(this Func <EventArgs> getEventData, Func <string, CancellationToken, Func <EventArgs>, Task> signal, CancellationToken token, string streamName, string eventName)
{
var eventDisplayName = EventFactory.SplitPascalCase(eventName).ToUpperInvariant();
var data = EventDataConverter.ConvertFrom(getEventData()); // also, we manually use our TypeConverter to return an appropriate type
if (data.Id != Events.Verbose && data.Id != Events.Warning && data.Id != Events.Debug && data.Id != Events.Information && data.Id != Events.Error)
{
await signal(streamName, token, () => EventFactory.CreateLogEvent($"{eventDisplayName} The contents are '{data?.Id}' and '{data?.Message}'"));
if (data != null)
{
await signal(streamName, token, () => EventFactory.CreateLogEvent($"{eventDisplayName} Parameter: '{data.Parameter}'\n{eventDisplayName} RequestMessage '{data.RequestMessage}'\n{eventDisplayName} Response: '{data.ResponseMessage}'\n{eventDisplayName} Value: '{data.Value}'"));
await signal(streamName, token, () => EventFactory.CreateLogEvent($"{eventDisplayName} ExtendedData Type: '{data.ExtendedData?.GetType()}'\n{eventDisplayName} ExtendedData '{data.ExtendedData}'"));
}
}
}
public void Gaucho_Filter_PropertyFormatter()
{
var converter = new EventDataConverter
{
new PropertyFilter("Level", "lvl"),
new PropertyFilter("Message"),
new FormatFilter("prop", "${lvl}_error_${Message}")
};
var input = new LogMessage
{
Level = "Info",
Message = "The message",
Title = "title"
};
var factory = new EventDataFactory();
var data = factory.BuildFrom(input);
data = converter.Convert(data);
var formatted = converter.Format("prop", data);
Assert.AreEqual(formatted, "Info_error_The message");
}
/// <summary>
/// build a converter based on the filters in the list
/// </summary>
/// <param name="filters"></param>
/// <returns></returns>
public static IEventDataConverter BuildDataFilter(this IEnumerable <string> filters)
{
var converter = new EventDataConverter();
if (filters == null)
{
return(converter);
}
foreach (var filterString in filters)
{
var filter = FilterFactory.BuildFilter(filterString);
if (filter == null)
{
var logger = LoggerConfiguration.Setup();
logger.Write($"Could not convert '{filterString}' to a Filter", Category.Log, LogLevel.Warning, source: "FilterFactory");
continue;
}
converter.Add(filter);
}
return(converter);
}
public void WhenRawEventDataIsEmpty()
{
var subject = new EventDataConverter ();
var actual = subject.FromEventData (
new RawEvent (this.eventData.Type, this.eventData.Metadata, new byte[0]));
actual.Body.EventType.Should ().Be<SimpleEvent> ();
actual.Body.EventData.Should ().BeEmpty ();
}
public void WhenRawEventMetadataIsNull()
{
var subject = new EventDataConverter ();
Action action = () => subject.FromEventData (
new RawEvent (this.eventData.Type, null, this.eventData.Data));
action.ShouldThrow<ArgumentException> ()
.WithMessage ("*event metadata is required*");
}
public void TestToEventData()
{
var expectedEventType = typeof(string);
var anyEvent = new AnyEvent (new AnyEventHeader {
EventId = "eventId"
}, new AnyEventBody {
EventType = expectedEventType,
EventData = "hi"
});
var subject = new EventDataConverter ();
var actual = subject.ToEventData (anyEvent);
actual.EventId.Should ().NotBeEmpty ();
actual.IsJson.Should ().BeTrue ();
actual.Type.Should ().Be (expectedEventType.AssemblyQualifiedName);
actual.Metadata.Should ().NotBeNull ();
actual.Metadata.Should ().NotBeEmpty ();
actual.Data.Should ().NotBeNull ();
actual.Data.Should ().NotBeEmpty ();
}
public void WhenEventBodyEventTypeIsMissing()
{
var subject = new EventDataConverter ();
var actual = subject.ToEventData (new AnyEvent (new AnyEventHeader (), new AnyEventBody ()));
actual.Type.Should ().BeNull ();
}
public void WhenEventHeaderIsMissing()
{
var subject = new EventDataConverter ();
Action action = () => subject.ToEventData (new AnyEvent (null, new AnyEventBody ()));
action.ShouldThrow<ArgumentException> ()
.WithMessage ("*event header is required*");
}
public void WhenEventIsNull()
{
var subject = new EventDataConverter ();
Action action = () => subject.ToEventData (null);
action.ShouldThrow<ArgumentNullException> ()
.WithMessage ("*eventToConvert*");
}
public void WhenRawEventDataIsNull()
{
var subject = new EventDataConverter ();
var actual = subject.FromEventData (
new RawEvent (this.eventData.Type, this.eventData.Metadata, null));
actual.Body.EventType.Should ().BeNull ();
actual.Body.EventData.Should ().BeNull ();
}
