public static async Task Main(string[] args)
{
using (var channel = GrpcChannel.ForAddress(QUERY_SERVICE_ADDRESS)) {
var queryService = new QueryService.QueryServiceClient(channel);
Console.WriteLine("Query service created");
var service = new MatchFunctionImpl(queryService);
Console.WriteLine("MatchFunctionImpl created");
Server server = null;
try {
server = new Server()
{
Services = { MatchFunction.BindService(service) },
Ports = { new ServerPort("0.0.0.0", SERVER_PORT, ServerCredentials.Insecure) }
};
Console.WriteLine("Grpc server created");
server.Start();
Console.WriteLine("Grpc server started");
await server.ShutdownTask;
} catch (Exception e) {
Console.WriteLine(e.ToString());
return;
} finally {
if (server != null)
{
server.ShutdownAsync().Wait();
}
}
}
}
public MatchFunctionImpl(QueryService.QueryServiceClient queryService)
{
this.queryService = queryService;
}
public async Task ExecuteAsync(CancellationToken stoppingToken)
{
var runInfo = new RunInfo {
LastRunTime = (DateTimeOffset.UtcNow - TimeSpan.FromHours(1)).UtcTicks
};
if (File.Exists("runInfo.json"))
{
using var r = new StreamReader("runInfo.json");
var json = await r.ReadToEndAsync();
runInfo = JsonConvert.DeserializeObject <RunInfo>(json);
}
var jaegerUrl = $"http://{_configuration["JaegerUrl"]}";
var channel = GrpcChannel.ForAddress(jaegerUrl);
var client = new QueryService.QueryServiceClient(channel);
var findTracesRequest = new FindTracesRequest
{
Query = new TraceQueryParameters
{
OperationName = "ProcessDataEvent",
ServiceName = "Orchestrator",
StartTimeMin = Timestamp.FromDateTimeOffset(new DateTimeOffset(runInfo.LastRunTime, TimeSpan.Zero)),
StartTimeMax = Timestamp.FromDateTimeOffset(DateTimeOffset.UtcNow),
SearchDepth = 1000
}
};
// I could store the time of the last run and look for traces since then...
// I could also keep track of all the traces ever looked up, and ignore those.
var streamResult = client.FindTraces(findTracesRequest, cancellationToken: stoppingToken).ResponseStream;
List <ByteString> traceIds = new List <ByteString>();
var currentTraceId = "";
TraceDetails currentTraceDetails = null;
using var fileName = File.OpenWrite(_configuration["outputPath"]);
using var textWriter = new StreamWriter(fileName);
var headers = string.Join(',', "tId"
, "dataPullType"
, "FromZone"
, "ToZone"
, "DataSize"
, "TotalDuration"
, "TriggerStepClientDuration"
, "TriggerStepServerDuration"
, "DataPullDuration"
, "DataPushDuration"
, "ComputeDuration"
, "DataMasterPullCall"
, "DataPeerPullCall"
, "DataMasterPushCall");
await textWriter.WriteLineAsync(headers);
while (await streamResult.MoveNext(CancellationToken.None))
{
var currentChunk = streamResult.Current;
// I need to identify the numbers on my figure.
// And then, for each trace, calculate the aggregates
foreach (var span in currentChunk.Spans)
{
if (runInfo.UsedTraceIds.Contains(span.TraceId.ToBase64()))
{
Console.WriteLine("Found an old trace, ignoring");
continue;
}
if (span.TraceId.ToBase64() != currentTraceId)
{
await textWriter.FlushAsync();
// new trace is starting.
if (currentTraceDetails != null)
{
await textWriter.WriteLineAsync(currentTraceDetails.ToString());
}
currentTraceDetails = new TraceDetails();
currentTraceId = span.TraceId.ToBase64();
currentTraceDetails.TraceId = currentTraceId;
traceIds.Add(span.TraceId);
}
AddInfoToCurrentTraceDetails(span, currentTraceDetails);
}
}
if (currentTraceDetails != null)
{
await textWriter.WriteLineAsync(currentTraceDetails.ToString());
}
foreach (var traceId in traceIds)
{
runInfo.UsedTraceIds.Add(traceId.ToBase64());
}
runInfo.LastRunTime = DateTimeOffset.UtcNow.Ticks;
await File.WriteAllTextAsync("runInfo.json", JsonConvert.SerializeObject(runInfo));
}
public static async Task <RepeatedField <Ticket> > QueryPoolAsync(ServerCallContext context, QueryService.QueryServiceClient queryService, Pool pool)
{
var query = queryService.QueryTickets(new QueryTicketsRequest()
{
Pool = pool
}, null, null, context.CancellationToken);
if (query == null)
{
return(null);
}
var tickets = new RepeatedField <Ticket>();
try {
while (await query.ResponseStream.MoveNext())
{
tickets.Add(query.ResponseStream.Current.Tickets);
}
} catch (Exception e) {
Console.WriteLine(e.ToString());
query.Dispose();
return(null);
} finally { if (query != null)
{
query.Dispose();
}
}
return(tickets);
}
public static async Task <Dictionary <string, RepeatedField <Ticket> > > QueryPoolsAsync(ServerCallContext context, QueryService.QueryServiceClient queryService, RepeatedField <Pool> pools)
{
var results = new List <Result>();
foreach (var pool in pools)
{
var result = new Result()
{
name = pool.Name
};
var tickets = await QueryPoolAsync(context, queryService, pool);
if (tickets == null || tickets.Count <= 0)
{
continue;
}
result.tickets = tickets;
results.Add(result);
if (context.CancellationToken.IsCancellationRequested)
{
Console.WriteLine("Context cancelled while querying pools");
break;
}
}
var poolMap = new Dictionary <string, RepeatedField <Ticket> >();
foreach (var result in results)
{
if (context.CancellationToken.IsCancellationRequested)
{
Console.WriteLine("Context cancelled while querying pools");
return(null);
}
poolMap[result.name] = result.tickets;
}
return(poolMap);
}
