private ITransport MakeTransport(GraylogSinkOptions options)
{
switch (options.TransportType)
{
case SerilogTransportType.Udp:
IDnsInfoProvider dns = new DnsWrapper();
IPAddress[] ipAddreses = Task.Run(() => dns.GetHostAddresses(options.HostnameOrAddress)).Result;
IPAddress ipAddress = ipAddreses.FirstOrDefault(c => c.AddressFamily == AddressFamily.InterNetwork);
var ipEndpoint = new IPEndPoint(ipAddress, options.Port);
IDataToChunkConverter chunkConverter = new DataToChunkConverter(new ChunkSettings
{
MessageIdGeneratorType = options.MessageGeneratorType
}, new MessageIdGeneratorResolver());
var udpClient = new UdpTransportClient(ipEndpoint);
var udpTransport = new UdpTransport(udpClient, chunkConverter);
return(udpTransport);
case SerilogTransportType.Http:
var httpClient = new HttpTransportClient($"{options.HostnameOrAddress}:{options.Port}/gelf");
var httpTransport = new HttpTransport(httpClient);
return(httpTransport);
default:
throw new ArgumentOutOfRangeException(nameof(options), options.TransportType, null);
}
}
public void WhenMessageIsLong_ThenSplitItToChunks()
{
byte[] giwenData = new byte[100000];
var idGenerator = new Mock <IMessageIdGenerator>();
var messageId = _fixture.CreateMany <byte>(8).ToArray();
idGenerator.Setup(c => c.GenerateMessageId(giwenData)).Returns(messageId);
_resolver.Setup(c => c.Resolve(_settings.MessageIdGeneratorType))
.Returns(idGenerator.Object);
var target = new DataToChunkConverter(_settings, _resolver.Object);
var actual = target.ConvertToChunks(giwenData);
Assert.True(actual.Count == 13);
for (int i = 0; i < actual.Count; i++)
{
actual[i].Take(2).ToArray().Should().BeEquivalentTo(new[] { 0x1e, 0x0f });
actual[i].Skip(2).Take(8).ToArray().Should().BeEquivalentTo(messageId);
actual[i].Skip(10).Take(1).First().Should().Be((byte)i);
actual[i].Skip(11).Take(1).First().Should().Be(13);
Assert.True(actual[i].Skip(12).All(c => c == 0));
}
}
public ITransport MakeTransport()
{
switch (_options.TransportType)
{
case SinkTransportType.Udp:
IDnsInfoProvider dns = new DnsWrapper();
IPAddress[] ipAddreses = Task.Run(() => dns.GetHostAddresses(_options.HostnameOrAddress)).Result;
IPAddress ipAddress = ipAddreses.FirstOrDefault(c => c.AddressFamily == AddressFamily.InterNetwork);
var ipEndpoint = new IPEndPoint(ipAddress ?? throw new InvalidOperationException(), _options.Port);
var chunkSettings = new ChunkSettings(_options.MessageGeneratorType, _options.MaxMessageSizeInUdp);
IDataToChunkConverter chunkConverter = new DataToChunkConverter(chunkSettings, new MessageIdGeneratorResolver());
var udpClient = new UdpTransportClient(ipEndpoint);
var udpTransport = new UdpTransport(udpClient, chunkConverter);
return(udpTransport);
case SinkTransportType.Http:
var httpClient = new HttpTransportClient($"{_options.HostnameOrAddress}:{_options.Port}/gelf");
var httpTransport = new HttpTransport(httpClient);
return(httpTransport);
default:
throw new ArgumentOutOfRangeException(nameof(_options), _options.TransportType, null);
}
}
public GraylogSink(GraylogSinkOptions options)
{
IDnsInfoProvider dns = new DnsWrapper();
IPAddress[] ipAddreses = Task.Run(() => dns.GetHostAddresses(options.HostnameOrAdress)).Result;
IPAddress ipAdress = ipAddreses.FirstOrDefault(c => c.AddressFamily == AddressFamily.InterNetwork);
var ipEndpoint = new IPEndPoint(ipAdress, options.Port);
IDataToChunkConverter chunkConverter = new DataToChunkConverter(new ChunkSettings
{
MessageIdGeneratorType = options.MessageGeneratorType
}, new MessageIdGeneratorResolver());
var client = new UdpTransportClient(ipEndpoint);
_transport = options.Transport ?? new UdpTransport(client, chunkConverter);
string hostName = Dns.GetHostName();
IDictionary <BuilderType, IMessageBuilder> builders = new Dictionary <BuilderType, IMessageBuilder>
{
[BuilderType.Exception] = new ExceptionMessageBuilder(hostName, options),
[BuilderType.Message] = new GelfMessageBuilder(hostName, options)
};
_converter = options.GelfConverter ?? new GelfConverter(builders);
}
public void WhenChunksWasTooMany_ThenThrowsException()
{
byte[] giwenData = new byte[10000000];
var target = new DataToChunkConverter(_settings, _resolver.Object);
Assert.Throws <ArgumentException>(() => target.ConvertToChunks(giwenData));
}
public void WhenConvertToChunkWithSmallData_ThenReturnsOneChunk()
{
var target = new DataToChunkConverter(_settings, _resolver.Object);
byte[] giwenData = _fixture.CreateMany <byte>(1000).ToArray();
IList <byte[]> actual = target.ConvertToChunks(giwenData);
var expected = new List <byte[]>()
{
giwenData
};
actual.Should().BeEquivalentTo(expected);
}
private static ITransport CreateSyncUdpTransport(GraylogSinkOptions options)
{
var chunkConverter = new DataToChunkConverter(new ChunkSettings
{
MessageIdGeneratorType = options.MessageGeneratorType
}, new MessageIdGeneratorResolver());
var udpTransport = new UdpTransport(
chunkConverter,
options.HostnameOrAddress,
options.Port,
options.UdpClientFactory
);
return(udpTransport);
}
public ITransport MakeTransport()
{
switch (_options.TransportType)
{
case SinkTransportType.Udp:
{
var ipAddress = Task.Run(() => GetIpAddress(_options.HostnameOrAddress)).GetAwaiter().GetResult();
var ipEndpoint = new IPEndPoint(ipAddress ?? throw new InvalidOperationException(), _options.Port.GetValueOrDefault(12201));
var chunkSettings = new ChunkSettings(_options.MessageGeneratorType, _options.MaxMessageSizeInUdp);
IDataToChunkConverter chunkConverter =
new DataToChunkConverter(chunkSettings, new MessageIdGeneratorResolver());
var udpClient = new UdpTransportClient(ipEndpoint);
var udpTransport = new UdpTransport(udpClient, chunkConverter);
return(udpTransport);
}
case SinkTransportType.Http: {
var builder = new UriBuilder(_options.HostnameOrAddress)
{
Port = _options.Port.GetValueOrDefault(12201),
Path = "gelf"
};
var httpClient = new HttpTransportClient(builder.Uri.ToString());
var httpTransport = new HttpTransport(httpClient);
return(httpTransport);
}
case SinkTransportType.Tcp:
{
var ipAddress = Task.Run(() => GetIpAddress(_options.HostnameOrAddress)).GetAwaiter().GetResult();
var tcpClient = new TcpTransportClient(ipAddress, _options.Port.GetValueOrDefault(12201), _options.UseSsl ? _options.HostnameOrAddress : null);
var transport = new TcpTransport(tcpClient);
return(transport);
}
default:
throw new ArgumentOutOfRangeException(nameof(_options), _options.TransportType, null);
}
}
public ITransport MakeTransport()
{
switch (_options.TransportType)
{
case SinkTransportType.Udp:
{
var ipAddress = Task.Run(() => GetIpAddress(_options.HostnameOrAddress)).GetAwaiter().GetResult();
var ipEndpoint = new IPEndPoint(ipAddress ?? throw new InvalidOperationException(), _options.Port);
var chunkSettings = new ChunkSettings(_options.MessageGeneratorType, _options.MaxMessageSizeInUdp);
IDataToChunkConverter chunkConverter =
new DataToChunkConverter(chunkSettings, new MessageIdGeneratorResolver());
var udpClient = new UdpTransportClient(ipEndpoint);
var udpTransport = new UdpTransport(udpClient, chunkConverter);
return(udpTransport);
}
case SinkTransportType.Http:
{
var httpClient = new HttpTransportClient($"{_options.HostnameOrAddress}:{_options.Port}/gelf");
var httpTransport = new HttpTransport(httpClient);
return(httpTransport);
}
case SinkTransportType.Tcp:
{
var ipAddress = Task.Run(() => GetIpAddress(_options.HostnameOrAddress)).GetAwaiter().GetResult();
var tcpClient = new TcpTransportClient(ipAddress, _options.Port);
Task.Run(() => tcpClient.Connect()).GetAwaiter().GetResult();
var transport = new TcpTransport(tcpClient);
return(transport);
}
default:
throw new ArgumentOutOfRangeException(nameof(_options), _options.TransportType, null);
}
}
public GraylogSink(GraylogSinkOptions options)
{
_transport = options.Transport;
if (_transport == null)
{
if (options.UseHttpTransport)
{
_converter = new HttpGelfConverter(options.Facility, options.ShortMessageMaxLength);
_transport = new HttpTransport(options.HostnameOrAdress); // should be in the form http://HostNameOrIp:Port//Gelf
}
else
{
IDnsInfoProvider dns = new DnsWrapper();
IPAddress[] ipAddreses = Task.Run(() => dns.GetHostAddresses(options.HostnameOrAdress)).Result;
IPAddress ipAdress = ipAddreses.FirstOrDefault(c => c.AddressFamily == AddressFamily.InterNetwork);
var ipEndpoint = new IPEndPoint(ipAdress, options.Port);
IDataToChunkConverter chunkConverter = new DataToChunkConverter(new ChunkSettings
{
MessageIdGeneratorType = options.MessageGeneratorType
}, new MessageIdGeneratorResolver());
var client = new UdpTransportClient(ipEndpoint);
_transport = new UdpTransport(client, chunkConverter);
}
}
string hostName = Dns.GetHostName();
IDictionary <BuilderType, IMessageBuilder> builders = new Dictionary <BuilderType, IMessageBuilder>
{
[BuilderType.Exception] = new ExceptionMessageBuilder(hostName, options),
[BuilderType.Message] = new GelfMessageBuilder(hostName, options)
};
_converter = options.GelfConverter ?? new GelfConverter(builders);
}
