public void Should_add_exception_data_to_event()
{
var builder = new HerculesEventBuilder();
sink.Put(stream, Arg.Do <Action <IHerculesEventBuilder> >(x => x(builder)));
var e = GetExceptionWithStacktrace();
log.Log(new LogEvent(LogLevel.Info, DateTimeOffset.UtcNow, Guid.NewGuid().ToString(), e));
var @event = builder.BuildEvent();
var exception = @event.Tags[LogEventTagNames.Exception]?.AsContainer;
var topFrame = exception?[ExceptionTagNames.StackFrames]?.AsVector.AsContainerList[0];
topFrame?[StackFrameTagNames.Function]
?.AsString
.Should()
.Be(nameof(GetExceptionWithStacktrace));
topFrame?[StackFrameTagNames.Type]
?.AsString
.Should()
.Be($"Vostok.Logging.Hercules.Tests.{GetType().Name}");
@event.Tags[LogEventTagNames.StackTrace]?.AsString.Should().Contain("Vostok.Logging.Hercules.Tests");
}
public static HerculesEvent Build([NotNull] ISpan span, [CanBeNull] IFormatProvider formatProvider = null)
{
var builder = new HerculesEventBuilder();
Build(span, builder, formatProvider);
return(builder.BuildEvent());
}
public void Should_extract_values()
{
var offset = 10.Hours();
var timestamp = DateTimeOffset.Now.ToOffset(offset);
var stackTrace = Guid.NewGuid().ToString();
var messageTemplate = Guid.NewGuid().ToString();
var renderedMessage = Guid.NewGuid().ToString();
var propKey = "prop1";
var propValue = 2;
var eventBuilder = new HerculesEventBuilder();
eventBuilder
.SetTimestamp(timestamp)
.AddValue(LogEventTagNames.MessageTemplate, messageTemplate)
.AddValue(LogEventTagNames.Message, renderedMessage)
.AddValue(LogEventTagNames.StackTrace, stackTrace)
.AddContainer(LogEventTagNames.Properties, b => b.AddValue(propKey, propValue))
.AddContainer(LogEventTagNames.Exception, delegate {});
var @event = eventBuilder.BuildEvent();
var logEventData = new LogEventData(@event);
logEventData.Timestamp.Should().Be(timestamp);
logEventData.MessageTemplate.Should().Be(messageTemplate);
logEventData.Message.Should().Be(renderedMessage);
logEventData.StackTrace.Should().Be(stackTrace);
logEventData.Properties.Should().NotBeNull();
logEventData.Properties[propKey].AsInt.Should().Be(propValue);
logEventData.Exception.Should().NotBeNull();
}
public static HerculesEvent ToEvent(this Action <IHerculesEventBuilder> eventBuilder)
{
var expectedEventBuilder = new HerculesEventBuilder();
eventBuilder(expectedEventBuilder);
return(expectedEventBuilder.BuildEvent());
}
public void Setup()
{
utcOffset = 3.Hours();
timestamp = new DateTimeOffset(DateTime.SpecifyKind(DateTime.UtcNow, DateTimeKind.Unspecified), utcOffset);
builder = new HerculesEventBuilder();
}
private static void CorruptEvent(Random random, HerculesEventBuilder builder)
{
if (random.Next(10) == 0)
{
builder.RemoveTags("tags");
}
if (random.Next(10) == 0)
{
builder.AddContainer("a", b => b.AddContainer("b", bb => bb.AddValue("value", "str")));
}
}
public void Should_format_OperationContextValue_as_vector_of_strings()
{
var builder = new HerculesEventBuilder();
sink.Put(stream, Arg.Do <Action <IHerculesEventBuilder> >(x => x(builder)));
log
.WithProperty(WellKnownProperties.OperationContext, new OperationContextValue(new[] { "op1", "{Name}", "op3" }))
.Info("Hello {Name}!", "Vostok");
var @event = builder.BuildEvent();
var vector = @event.Tags[LogEventTagNames.Properties]?.AsContainer[WellKnownProperties.OperationContext]?.AsVector;
vector?.AsStringList.Should().Equal("op1", "Vostok", "op3");
}
public void Should_save_SourceContextValue_as_vector_of_strings()
{
var builder = new HerculesEventBuilder();
sink.Put(stream, Arg.Do <Action <IHerculesEventBuilder> >(x => x(builder)));
log
.ForContext("src1")
.ForContext("src2")
.Info("Hello!");
var @event = builder.BuildEvent();
var vector = @event.Tags[LogEventTagNames.Properties]?.AsContainer[WellKnownProperties.SourceContext]?.AsVector;
vector?.AsStringList.Should().Equal("src1", "src2");
}
public void TestSetup()
{
originalSpan = Substitute.For <ISpan>();
originalSpan.TraceId.Returns(Guid.NewGuid());
originalSpan.SpanId.Returns(Guid.NewGuid());
builder = new HerculesEventBuilder();
@event = null;
sink = Substitute.For <IHerculesSink>();
sink
.When(s => s.Put(Arg.Any <string>(), Arg.Any <Action <IHerculesEventBuilder> >()))
.Do(info => info.Arg <Action <IHerculesEventBuilder> >().Invoke(builder));
sender = new HerculesSpanSender(new HerculesSpanSenderSettings(sink, Guid.NewGuid().ToString()));
}
private HerculesEvent TestSerialization(Action <IHerculesEventBuilder> build)
{
var memoryBuilder = new HerculesEventBuilder();
memoryBuilder.SetTimestamp(defaultTimestamp);
build(memoryBuilder);
var memoryEvent = memoryBuilder.BuildEvent();
var binaryWriter = new BinaryBufferWriter(16)
{
Endianness = Endianness.Big
};
binaryWriter.Write(3);
for (var i = 0; i < 3; i++)
{
using (var binaryBuilder = new BinaryEventBuilder(binaryWriter, () => defaultTimestamp, Constants.EventProtocolVersion))
{
build(binaryBuilder);
}
}
var events = EventsBinaryReader.Read(binaryWriter.Buffer, 0, _ => new HerculesEventBuilderGeneric(), new SynchronousConsoleLog());
events.Count.Should().Be(3);
events.Should().AllBeEquivalentTo(memoryEvent);
var dummyEvents = EventsBinaryReader.Read(binaryWriter.Buffer, 0, b => DummyEventBuilder.Instance, new SynchronousConsoleLog());
dummyEvents.Count.Should().Be(3);
return(events.Last());
}
public void Should_correctly_build_events_from_buffer()
{
var management = Hercules.Instance.Management;
management.CreateStream(
new CreateStreamQuery(streamName)
{
ShardingKey = new[] { "hash" },
Partitions = 1
},
timeout);
var events = new List <HerculesEvent>();
var random = new Random();
for (var i = 0; i < 1000; i++)
{
var tags = MetricTags.Empty
.Append("common", "value")
.Append("id", (i % 10).ToString());
var @event = new MetricEvent(
i,
tags,
DateTimeOffset.UtcNow,
WellKnownUnits.Milliseconds,
WellKnownAggregationTypes.Counter,
new Dictionary <string, string>
{
["common-param"] = "param",
["id-param"] = (i % 10).ToString()
});
var builder = new HerculesEventBuilder();
HerculesEventMetricBuilder.Build(@event, builder);
CorruptEvent(random, builder);
events.Add(builder.BuildEvent());
}
Hercules.Instance.Gate.Insert(new InsertEventsQuery(streamName, events), timeout).EnsureSuccess();
var actual = Hercules.Instance.MetricsStream.Read(new ReadStreamQuery(streamName), timeout).Payload.Events;
var expected = new List <MetricEvent>();
foreach (var @event in events)
{
try
{
expected.Add(HerculesMetricEventFactory.CreateFrom(@event));
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception)
{
}
}
actual.Should().BeEquivalentTo(expected);
}
