private static async Task RunSelectedConfigurationAsync(Transport transport, Buffering buffering, Protocol protocol, bool multiplex, CancellationToken cancellationToken)
{
TServerTransport serverTransport = transport switch
{
Transport.Tcp => new TServerSocketTransport(9090, Configuration),
Transport.NamedPipe => new TNamedPipeServerTransport(".test", Configuration, NamedPipeClientFlags.None),
Transport.TcpTls => new TTlsServerSocketTransport(9090, Configuration, GetCertificate(), ClientCertValidator, LocalCertificateSelectionCallback),
_ => throw new ArgumentException("unsupported value $transport", nameof(transport)),
};
TTransportFactory transportFactory = buffering switch
{
Buffering.Buffered => new TBufferedTransport.Factory(),
Buffering.Framed => new TFramedTransport.Factory(),
// layered transport(s) are optional
Buffering.None => null,
_ => throw new ArgumentException("unsupported value $buffering", nameof(buffering)),
};
TProtocolFactory protocolFactory = protocol switch
{
Protocol.Binary => new TBinaryProtocol.Factory(),
Protocol.Compact => new TCompactProtocol.Factory(),
Protocol.Json => new TJsonProtocol.Factory(),
_ => throw new ArgumentException("unsupported value $protocol", nameof(protocol)),
};
var handler = new CalculatorAsyncHandler();
ITAsyncProcessor processor = new Calculator.AsyncProcessor(handler);
if (multiplex)
{
var multiplexedProcessor = new TMultiplexedProcessor();
multiplexedProcessor.RegisterProcessor(nameof(Calculator), processor);
processor = multiplexedProcessor;
}
try
{
Logger.LogInformation(
"TSimpleAsyncServer with \n{transport} transport\n{buffering} buffering\nmultiplex = {multiplex}\n{protocol} protocol",
transport,
buffering,
multiplex ? "yes" : "no",
protocol
);
var server = new TSimpleAsyncServer(
itProcessorFactory: new TSingletonProcessorFactory(processor),
serverTransport: serverTransport,
inputTransportFactory: transportFactory,
outputTransportFactory: transportFactory,
inputProtocolFactory: protocolFactory,
outputProtocolFactory: protocolFactory,
logger: LoggingHelper.CreateLogger <TSimpleAsyncServer>());
Logger.LogInformation("Starting the server...");
await server.ServeAsync(cancellationToken);
}
catch (Exception x)
{
Logger.LogInformation("{x}", x);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="THttpTaskAsyncHandler"/> class.
/// </summary>
/// <param name="processor">The async processor implementation.</param>
/// <param name="inputProtocolFactory">The input protocol factory.</param>
/// <param name="outputProtocolFactory">The output protocol factory.</param>
public THttpTaskAsyncHandler(TAsyncProcessor processor, TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory)
{
_processor = processor;
_inputProtocolFactory = inputProtocolFactory;
_outputProtocolFactory = outputProtocolFactory;
}
public TThreadPoolServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory transportFactory,
TProtocolFactory protocolFactory)
: this(processor, serverTransport,
transportFactory, transportFactory,
protocolFactory, protocolFactory,
DEFAULT_MIN_THREADS, DEFAULT_MAX_THREADS)
{
}
public TThreadPoolServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory transportFactory,
TProtocolFactory protocolFactory)
: this(new TSingletonProcessorFactory(processor), serverTransport,
transportFactory, transportFactory,
protocolFactory, protocolFactory,
DEFAULT_MIN_THREADS, DEFAULT_MAX_THREADS, DefaultLogDelegate)
{
}
public TThreadedServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory transportFactory,
TProtocolFactory protocolFactory)
: this(processor, serverTransport,
transportFactory, transportFactory,
protocolFactory, protocolFactory,
DEFAULT_MAX_THREADS, DefaultLogDelegate)
{
}
public ThriftConnection(IConnectionConfigurationValues connectionSettings, TProtocolFactory protocolFactory = null)
{
this._connectionSettings = connectionSettings;
this._protocolFactory = protocolFactory;
this._timeout = connectionSettings.Timeout;
this._maximumConnections = this._connectionSettings.MaximumAsyncConnections;
if (this._maximumConnections > 0)
this._resourceLock = new Semaphore(this._maximumConnections, this._maximumConnections);
}
public TSimpleServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory transportFactory,
TProtocolFactory protocolFactory)
: base(processor,
serverTransport,
transportFactory,
transportFactory,
protocolFactory,
protocolFactory)
{
}
public TThreadPoolAsyncServer(ITProcessorFactory processorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
int minThreadPoolThreads, int maxThreadPoolThreads, ILogger logger = null)
: this(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory,
new Configuration(minThreadPoolThreads, maxThreadPoolThreads),
logger)
{
}
public TThreadPoolServer(TProcessorFactory processorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
int minThreadPoolThreads, int maxThreadPoolThreads, LogDelegate logDel)
: this(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory,
new Configuration(minThreadPoolThreads, maxThreadPoolThreads),
logDel)
{
}
public TSimpleServer(TProcessorFactory processorFactory,
TServerTransport serverTransport,
TTransportFactory transportFactory,
TProtocolFactory protocolFactory)
: base(processorFactory,
serverTransport,
transportFactory,
transportFactory,
protocolFactory,
protocolFactory,
DefaultLogDelegate)
{
}
public void Write <T>(T tValue,
Stream oStream,
TProtocolFactory protocolFactory)
{
Guard.ArgumentNotNull(tValue, nameof(tValue));
Guard.ArgumentNotNull(protocolFactory, nameof(protocolFactory));
Guard.ArgumentNotNull(oStream, nameof(oStream));
TStreamTransport resultIOStream = new TStreamTransport(null, oStream);
TProtocol resultProtocolBuffer = protocolFactory.GetProtocol(resultIOStream);
Write <T>(tValue, resultProtocolBuffer);
}
public TSimpleServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory transportFactory,
TProtocolFactory protocolFactory)
: base(processor,
serverTransport,
transportFactory,
transportFactory,
protocolFactory,
protocolFactory,
DefaultLogDelegate)
{
}
protected TServer(ITProcessorFactory processorFactory, TServerTransport serverTransport,
TTransportFactory inputTransportFactory, TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory, TProtocolFactory outputProtocolFactory,
ILogger logger = null)
{
ProcessorFactory = processorFactory ?? throw new ArgumentNullException(nameof(processorFactory));
ServerTransport = serverTransport;
InputTransportFactory = inputTransportFactory ?? new TTransportFactory();
OutputTransportFactory = outputTransportFactory ?? new TTransportFactory();
InputProtocolFactory = inputProtocolFactory ?? throw new ArgumentNullException(nameof(inputProtocolFactory));
OutputProtocolFactory = outputProtocolFactory ?? throw new ArgumentNullException(nameof(outputProtocolFactory));
Logger = logger; // null is absolutely legal
}
public TServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory transportFactory,
TProtocolFactory protocolFactory)
: this(processor,
serverTransport,
transportFactory,
transportFactory,
protocolFactory,
protocolFactory,
DefaultLogDelegate)
{
}
public JaegerUdpBatcher(JaegerExporterOptions options, TTransport clientTransport = null)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.MaxFlushInterval <= TimeSpan.Zero)
{
options.MaxFlushInterval = TimeSpan.FromSeconds(10);
}
this.maxPacketSize = (!options.MaxPacketSize.HasValue || options.MaxPacketSize <= 0) ? JaegerExporterOptions.DefaultMaxPacketSize : options.MaxPacketSize.Value;
this.protocolFactory = new TCompactProtocol.Factory();
this.clientTransport = clientTransport ?? new JaegerThriftClientTransport(options.AgentHost, options.AgentPort);
this.thriftClient = new JaegerThriftClient(this.protocolFactory.GetProtocol(this.clientTransport));
this.memoryTransport = new InMemoryTransport(16000);
this.memoryProtocol = this.protocolFactory.GetProtocol(this.memoryTransport);
this.Process = new Process(options.ServiceName, options.ProcessTags);
this.maxFlushInterval = options.MaxFlushInterval;
this.maxFlushIntervalTimer = new System.Timers.Timer
{
AutoReset = false,
Enabled = false,
Interval = this.maxFlushInterval.TotalMilliseconds,
};
this.maxFlushIntervalTimer.Elapsed += async(sender, args) =>
{
bool lockTaken = this.flushLock.Wait(0);
try
{
if (!lockTaken)
{
// If the lock was already held, it means a flush is already executing.
return;
}
await this.FlushAsyncInternal(lockAlreadyHeld : true, CancellationToken.None).ConfigureAwait(false);
}
finally
{
if (lockTaken)
{
this.flushLock.Release();
}
}
};
}
public TSimpleAsyncServer(ITAsyncProcessor processor,
TServerTransport serverTransport,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
ILoggerFactory loggerFactory)
: this(new TSingletonProcessorFactory(processor),
serverTransport,
null, // defaults to TTransportFactory()
null, // defaults to TTransportFactory()
inputProtocolFactory,
outputProtocolFactory,
loggerFactory.CreateLogger(nameof(TSimpleAsyncServer)))
{
}
public TThreadPoolServer(TProcessorFactory processorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
Configuration threadConfig,
LogDelegate logDel)
: base(processorFactory, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory, logDel)
{
lock (typeof(TThreadPoolServer))
{
if ((threadConfig.MaxWorkerThreads > 0) || (threadConfig.MaxIOThreads > 0))
{
int work, comm;
ThreadPool.GetMaxThreads(out work, out comm);
if (threadConfig.MaxWorkerThreads > 0)
{
work = threadConfig.MaxWorkerThreads;
}
if (threadConfig.MaxIOThreads > 0)
{
comm = threadConfig.MaxIOThreads;
}
if (!ThreadPool.SetMaxThreads(work, comm))
{
throw new Exception("Error: could not SetMaxThreads in ThreadPool");
}
}
if ((threadConfig.MinWorkerThreads > 0) || (threadConfig.MinIOThreads > 0))
{
int work, comm;
ThreadPool.GetMinThreads(out work, out comm);
if (threadConfig.MinWorkerThreads > 0)
{
work = threadConfig.MinWorkerThreads;
}
if (threadConfig.MinIOThreads > 0)
{
comm = threadConfig.MinIOThreads;
}
if (!ThreadPool.SetMinThreads(work, comm))
{
throw new Exception("Error: could not SetMinThreads in ThreadPool");
}
}
}
}
public TServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory)
{
this.processor = processor;
this.serverTransport = serverTransport;
this.inputTransportFactory = inputTransportFactory;
this.outputTransportFactory = outputTransportFactory;
this.inputProtocolFactory = inputProtocolFactory;
this.outputProtocolFactory = outputProtocolFactory;
}
public TThreadedServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
int maxThreads, LogDelegate logDel)
: base(processor, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory, logDel)
{
this.maxThreads = maxThreads;
clientQueue = new Queue<TTransport>();
clientLock = new object();
clientThreads = new THashSet<Thread>();
}
public TThreadPoolServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
int minThreadPoolThreads, int maxThreadPoolThreads, LogDelegate logDel)
: base(processor, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory, logDel)
{
if (!ThreadPool.SetMaxThreads(maxThreadPoolThreads, maxThreadPoolThreads))
{
throw new Exception("Error: could not SetMaxThreads in ThreadPool");
}
}
public TThreadPoolServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
int minThreadPoolThreads, int maxThreadPoolThreads, LogDelegate logDel)
: base(processor, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory, logDel)
{
if (!ThreadPool.SetMaxThreads(maxThreadPoolThreads, maxThreadPoolThreads))
{
throw new Exception("Error: could not SetMaxThreads in ThreadPool");
}
}
public TThreadedServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
int maxThreads, LogDelegate logDel)
: base(processor, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory, logDel)
{
this.maxThreads = maxThreads;
clientQueue = new Queue <TTransport>();
clientLock = new object();
clientThreads = new THashSet <Thread>();
}
internal JaegerExporter(JaegerExporterOptions options, TTransport clientTransport = null)
{
Guard.Null(options, nameof(options));
this.maxPayloadSizeInBytes = (!options.MaxPayloadSizeInBytes.HasValue || options.MaxPayloadSizeInBytes <= 0) ? JaegerExporterOptions.DefaultMaxPayloadSizeInBytes : options.MaxPayloadSizeInBytes.Value;
this.protocolFactory = new TCompactProtocol.Factory();
this.clientTransport = clientTransport ?? new JaegerThriftClientTransport(options.AgentHost, options.AgentPort);
this.thriftClient = new JaegerThriftClient(this.protocolFactory.GetProtocol(this.clientTransport));
this.memoryTransport = new InMemoryTransport(16000);
this.memoryProtocol = this.protocolFactory.GetProtocol(this.memoryTransport);
string serviceName = (string)this.ParentProvider.GetDefaultResource().Attributes.Where(
pair => pair.Key == ResourceSemanticConventions.AttributeServiceName).FirstOrDefault().Value;
this.Process = new Process(serviceName);
}
public T Read <T>(byte[] serializedStruct,
TProtocolFactory protocolFactory)
{
Guard.ArgumentNotNull(serializedStruct, nameof(serializedStruct));
using (MemoryStream istream = new MemoryStream(serializedStruct))
{
using (TStreamTransport resultIOStream = new TStreamTransport(istream, null))
{
using (TProtocol resultProtocolBuffer = protocolFactory.GetProtocol(resultIOStream))
{
return(Read <T>(resultProtocolBuffer));
}
}
}
}
private bool disposedValue; // To detect redundant dispose calls
internal JaegerExporter(JaegerExporterOptions options, TTransport clientTransport = null)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
this.maxPayloadSizeInBytes = (!options.MaxPayloadSizeInBytes.HasValue || options.MaxPayloadSizeInBytes <= 0) ? JaegerExporterOptions.DefaultMaxPayloadSizeInBytes : options.MaxPayloadSizeInBytes.Value;
this.protocolFactory = new TCompactProtocol.Factory();
this.clientTransport = clientTransport ?? new JaegerThriftClientTransport(options.AgentHost, options.AgentPort);
this.thriftClient = new JaegerThriftClient(this.protocolFactory.GetProtocol(this.clientTransport));
this.memoryTransport = new InMemoryTransport(16000);
this.memoryProtocol = this.protocolFactory.GetProtocol(this.memoryTransport);
this.Process = new Process(options.ServiceName, options.ProcessTags);
}
public TSimpleAsyncServer(ITProcessorFactory itProcessorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
ILoggerFactory loggerFactory)
: this(itProcessorFactory,
serverTransport,
inputTransportFactory,
outputTransportFactory,
inputProtocolFactory,
outputProtocolFactory,
loggerFactory.CreateLogger <TSimpleAsyncServer>())
{
}
public TServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
LogDelegate logDelegate)
{
this.processor = processor;
this.serverTransport = serverTransport;
this.inputTransportFactory = inputTransportFactory;
this.outputTransportFactory = outputTransportFactory;
this.inputProtocolFactory = inputProtocolFactory;
this.outputProtocolFactory = outputProtocolFactory;
this.logDelegate = (logDelegate != null) ? logDelegate : DefaultLogDelegate;
}
public TSimpleAsyncServer(ITProcessorFactory itProcessorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
ILogger logger)
: base(itProcessorFactory,
serverTransport,
inputTransportFactory,
outputTransportFactory,
inputProtocolFactory,
outputProtocolFactory,
logger)
{
}
public T CreateScribeClient <T>(
ThriftClientManager manager, ScopedServer server, TProtocolFactory protocolFactory)
where T : class
{
ThriftClientConfig config = new ThriftClientConfig();
config.ConnectTimeout = TimeSpan.FromSeconds(600);
config.ReceiveTimeout = TimeSpan.FromSeconds(600);
config.ReadTimeout = TimeSpan.FromSeconds(600);
config.WriteTimeout = TimeSpan.FromSeconds(600);
var thriftClient = new ThriftClient(manager, typeof(T), config, typeof(T).Name);
return(thriftClient.OpenAsync(
new FramedClientConnector("localhost", server.Port, protocolFactory))
.GetAwaiter().GetResult() as T);
}
public TSimpleAsyncServer(ITProcessorFactory itProcessorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
ILogger logger,
int clientWaitingDelay = 10)
: base(itProcessorFactory,
serverTransport,
inputTransportFactory,
outputTransportFactory,
inputProtocolFactory,
outputProtocolFactory,
logger)
{
_clientWaitingDelay = clientWaitingDelay;
}
public TSimpleAsyncServer(ITProcessorFactory itProcessorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
ILoggerFactory loggerFactory,
int clientWaitingDelay = 10)
: this(itProcessorFactory,
serverTransport,
inputTransportFactory,
outputTransportFactory,
inputProtocolFactory,
outputProtocolFactory,
loggerFactory.CreateLogger <TSimpleAsyncServer>(),
clientWaitingDelay)
{
}
public TThreadPoolServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
int minThreadPoolThreads, int maxThreadPoolThreads, LogDelegate logDel)
: base(processor, serverTransport, inputTransportFactory, outputTransportFactory,
inputProtocolFactory, outputProtocolFactory, logDel)
{
// Can't SetMinThreads in NetStandard (?)
//if (!ThreadPool.SetMinThreads(minThreadPoolThreads, minThreadPoolThreads))
//{
// throw new Exception("Error: could not SetMinThreads in ThreadPool");
//}
//if (!ThreadPool.SetMaxThreads(maxThreadPoolThreads, maxThreadPoolThreads))
//{
// throw new Exception("Error: could not SetMaxThreads in ThreadPool");
//}
}
private bool disposedValue = false; // To detect redundant calls
public JaegerUdpBatcher(JaegerExporterOptions options, TTransport clientTransport = null)
{
if (options is null)
{
throw new ArgumentNullException(nameof(options));
}
if (options.MaxFlushInterval <= TimeSpan.Zero)
{
options.MaxFlushInterval = TimeSpan.FromSeconds(10);
}
this.maxPacketSize = (!options.MaxPacketSize.HasValue || options.MaxPacketSize <= 0) ? JaegerExporterOptions.DefaultMaxPacketSize : options.MaxPacketSize.Value;
this.protocolFactory = new TCompactProtocol.Factory();
this.clientTransport = clientTransport ?? new JaegerThriftClientTransport(options.AgentHost, options.AgentPort);
this.thriftClient = new JaegerThriftClient(this.protocolFactory.GetProtocol(this.clientTransport));
this.memoryTransport = new InMemoryTransport(16000);
this.memoryProtocol = this.protocolFactory.GetProtocol(this.memoryTransport);
this.Process = new Process(options.ServiceName, options.ProcessTags);
this.maxFlushInterval = options.MaxFlushInterval;
this.maxFlushIntervalTimer = new System.Timers.Timer
{
AutoReset = false,
Enabled = false,
Interval = this.maxFlushInterval.TotalMilliseconds,
};
this.maxFlushIntervalTimer.Elapsed += async(sender, args) =>
{
try
{
await this.FlushAsyncInternal(false, CancellationToken.None).ConfigureAwait(false);
}
catch (Exception ex)
{
JaegerExporterEventSource.Log.UnexpectedError(ex);
}
};
}
public THttpServerTransport(
ITAsyncProcessor processor,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
TTransportFactory inputTransFactory = null,
TTransportFactory outputTransFactory = null,
RequestDelegate next = null,
ILoggerFactory loggerFactory = null)
{
// loggerFactory == null is not illegal anymore
Processor = processor ?? throw new ArgumentNullException(nameof(processor));
InputProtocolFactory = inputProtocolFactory ?? throw new ArgumentNullException(nameof(inputProtocolFactory));
OutputProtocolFactory = outputProtocolFactory ?? throw new ArgumentNullException(nameof(outputProtocolFactory));
InputTransportFactory = inputTransFactory;
OutputTransportFactory = outputTransFactory;
_next = next;
_logger = (loggerFactory != null) ? loggerFactory.CreateLogger <THttpServerTransport>() : new NullLogger <THttpServerTransport>();
}
internal JaegerExporter(JaegerExporterOptions options, TProtocolFactory protocolFactory = null, IJaegerClient client = null)
{
Guard.ThrowIfNull(options, nameof(options));
this.maxPayloadSizeInBytes = (!options.MaxPayloadSizeInBytes.HasValue || options.MaxPayloadSizeInBytes <= 0)
? JaegerExporterOptions.DefaultMaxPayloadSizeInBytes
: options.MaxPayloadSizeInBytes.Value;
if (options.Protocol == JaegerExportProtocol.UdpCompactThrift)
{
protocolFactory ??= new TCompactProtocol.Factory();
client ??= new JaegerUdpClient(options.AgentHost, options.AgentPort);
this.sendUsingEmitBatchArgs = true;
}
else if (options.Protocol == JaegerExportProtocol.HttpBinaryThrift)
{
protocolFactory ??= new TBinaryProtocol.Factory();
client ??= new JaegerHttpClient(
options.Endpoint,
options.HttpClientFactory?.Invoke() ?? throw new InvalidOperationException("JaegerExporterOptions was missing HttpClientFactory or it returned null."));
}
else
{
throw new NotSupportedException();
}
this.client = client;
this.batchWriter = protocolFactory.GetProtocol(this.maxPayloadSizeInBytes * 2);
this.spanWriter = protocolFactory.GetProtocol(this.maxPayloadSizeInBytes);
string serviceName = (string)this.ParentProvider.GetDefaultResource().Attributes.FirstOrDefault(
pair => pair.Key == ResourceSemanticConventions.AttributeServiceName).Value;
this.Process = new Process(serviceName);
client.Connect();
}
public WordbookHandler()
{
this.processor = new WordbookThriftService.Processor(WordbookService);
this.inputProtocolFactory = this.outputProtocolFactory = new TJSONProtocol.Factory();
//this.inputProtocolFactory = this.outputProtocolFactory = new TBinaryProtocol.Factory();
}
public TServer(TProcessorFactory processorFactory,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
LogDelegate logDelegate)
{
this.processorFactory = processorFactory;
this.serverTransport = serverTransport;
this.inputTransportFactory = inputTransportFactory;
this.outputTransportFactory = outputTransportFactory;
this.inputProtocolFactory = inputProtocolFactory;
this.outputProtocolFactory = outputProtocolFactory;
this.logDelegate = (logDelegate != null) ? logDelegate : DefaultLogDelegate;
}
public THttpHandler(TProcessor processor, TProtocolFactory inputProtocolFactory, TProtocolFactory outputProtocolFactory)
{
this.processor = processor;
this.inputProtocolFactory = inputProtocolFactory;
this.outputProtocolFactory = outputProtocolFactory;
}
public THttpHandler(TProcessor processor, TProtocolFactory protocolFactory)
: this(processor, protocolFactory, protocolFactory)
{
}
public THttpHandler(TProcessor processor, TProtocolFactory protocolFactory)
: this(processor, protocolFactory, protocolFactory)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="THttpTaskAsyncHandler"/> class
/// using <paramref name="protocolFactory"/> for both input and output streams.
/// </summary>
/// <param name="processor">The async processor implementation.</param>
/// <param name="protocolFactory">The protocol factory.</param>
public THttpTaskAsyncHandler(TAsyncProcessor processor, TProtocolFactory protocolFactory)
: this(processor, protocolFactory, protocolFactory)
{
}
public void JaegerTraceExporter_SpansSplitToBatches_SpansIncludedInBatches(string protocolType, int maxPayloadSizeInBytes)
{
TProtocolFactory protocolFactory = protocolType == "Compact"
? new TCompactProtocol.Factory()
: new TBinaryProtocol.Factory();
var client = new TestJaegerClient();
// Arrange
using var jaegerExporter = new JaegerExporter(
new JaegerExporterOptions { MaxPayloadSizeInBytes = maxPayloadSizeInBytes },
protocolFactory,
client);
jaegerExporter.SetResourceAndInitializeBatch(Resource.Empty);
// Create six spans, each taking more space than the previous one
var spans = new JaegerSpan[6];
for (int i = 0; i < 6; i++)
{
spans[i] = CreateTestJaegerSpan(
additionalAttributes: new Dictionary <string, object>
{
["foo"] = new string('_', 10 * i),
});
}
var protocol = protocolFactory.GetProtocol();
var serializedSpans = spans.Select(s =>
{
s.Write(protocol);
var data = protocol.WrittenData.ToArray();
protocol.Clear();
return(data);
}).ToArray();
// Act
var sentBatches = new List <byte[]>();
foreach (var span in spans)
{
jaegerExporter.AppendSpan(span);
var sentBatch = client.LastWrittenData;
if (sentBatch != null)
{
sentBatches.Add(sentBatch);
client.LastWrittenData = null;
}
}
// Assert
// Appending the six spans will send two batches with the first four spans
Assert.Equal(2, sentBatches.Count);
Assert.True(
ContainsSequence(sentBatches[0], serializedSpans[0]),
"Expected span data not found in sent batch");
Assert.True(
ContainsSequence(sentBatches[0], serializedSpans[1]),
"Expected span data not found in sent batch");
Assert.True(
ContainsSequence(sentBatches[1], serializedSpans[2]),
"Expected span data not found in sent batch");
Assert.True(
ContainsSequence(sentBatches[1], serializedSpans[3]),
"Expected span data not found in sent batch");
// jaegerExporter.Batch should contain the two remaining spans
Assert.Equal(2U, jaegerExporter.NumberOfSpansInCurrentBatch);
jaegerExporter.SendCurrentBatch();
Assert.True(client.LastWrittenData != null);
var serializedBatch = client.LastWrittenData;
Assert.True(
ContainsSequence(serializedBatch, serializedSpans[4]),
"Expected span data not found in unsent batch");
Assert.True(
ContainsSequence(serializedBatch, serializedSpans[5]),
"Expected span data not found in unsent batch");
}
public TServer(TProcessor processor, TServerTransport serverTransport, TTransportFactory transportFactory, TProtocolFactory protocolFactory) : this(processor, serverTransport, transportFactory, transportFactory, protocolFactory, protocolFactory, new TServer.LogDelegate(TServer.DefaultLogDelegate))
{
}
public DefaultThriftFrameCodec(long maxFrameSize, TProtocolFactory inputProtocolFactory, ILoggerFactory loggerFactory = null)
{
this._decoder = new DefaultThriftFrameDecoder(maxFrameSize, inputProtocolFactory);
this._encoder = new DefaultThriftFrameEncoder(maxFrameSize);
_logger = loggerFactory?.CreateLogger <DefaultThriftFrameCodec>() ?? (ILogger)NullLogger.Instance;
}
public THttpHandler(TProcessor processor, TProtocolFactory inputProtocolFactory, TProtocolFactory outputProtocolFactory)
{
this.processor = processor;
this.inputProtocolFactory = inputProtocolFactory;
this.outputProtocolFactory = outputProtocolFactory;
}
public TServer(TProcessor processor,
TServerTransport serverTransport,
TTransportFactory inputTransportFactory,
TTransportFactory outputTransportFactory,
TProtocolFactory inputProtocolFactory,
TProtocolFactory outputProtocolFactory,
LogDelegate logDelegate)
{
this.processor = processor;
this.serverTransport = serverTransport;
this.inputTransportFactory = inputTransportFactory;
this.outputTransportFactory = outputTransportFactory;
this.inputProtocolFactory = inputProtocolFactory;
this.outputProtocolFactory = outputProtocolFactory;
this.logDelegate = logDelegate;
}
