Files
spark/src/DataStreamSuite/SharedStreams/StreamFactories/AvgOrderLatencyStreamFactory.cs
T

107 lines
3.7 KiB
C#

namespace bts.SilverPine;
using BCG;
using bts.api.core;
using bts.SilverPine.StreamFactory.Logging;
using bts.SilverPine.Tables;
using Bts.DataStream;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Reactive.Linq;
public class AvgOrderLatencyStreamFactory : IDataStreamFactory {
readonly DatabaseConfig config;
readonly ILogger logger;
public AvgOrderLatencyStreamFactory(IOptions<DatabaseConfig> config, ILogger<AvgOrderLatencyStreamFactory> logger)
: this(config.Value, logger) { }
public AvgOrderLatencyStreamFactory(DatabaseConfig config, ILogger<AvgOrderLatencyStreamFactory> logger) {
this.config = config;
this.logger = logger;
}
public static IObservable<TableUpdate<AvgOrderLatencyRow, int>>? CreateAvgOrderLatencyTables(
DatabaseConfig config, HistoricDataParams args, ILogger logger) {
args.Validate().ValidateInterval();
var orderLatencyParams = new OrderLatencyStreamParams() {
Venue = args.Venue,
Symbol = args.Symbol,
BeginDate = args.BeginDate,
EndDate = args.EndDate,
};
return OrderLatencyStreamFactory.CreateOrderLatencyTables(config, orderLatencyParams, logger)
?.BufferTable(TimeSpan.FromMilliseconds(500))
?.GroupTable(
r => r.Id,
r => (int)((r.Timestamp.Ticks - args.BeginDate.Ticks) / args.Interval!.Value.Ticks))
?.SelectKeyValue(ComputeAvgLatency, r => r.Id);
AvgOrderLatencyRow ComputeAvgLatency(TableUpdateGrouping<OrderLatencyRow, int, int> group) {
double avgLatency = 0;
double latencySum = 0;
int nTotal = 0;
int n = 0;
foreach (var r in group.table.state.Values) {
if ((double.MaxValue - latencySum) > r.Latency.Ticks) {
latencySum += r.Latency.Ticks;
n++;
} else if (n > 0) {
nTotal += n;
avgLatency += ((latencySum / n) - avgLatency) * (n / nTotal);
latencySum = 0;
n = 0;
} else {
throw new InvalidOperationException("Latency is too long (unable to compute the avg)");
}
}
if (n > 0) {
nTotal += n;
avgLatency += ((latencySum / n) - avgLatency) * (n / nTotal);
latencySum = 0;
n = 0;
}
return new AvgOrderLatencyRow() {
Symbol = args.Symbol,
Venue = args.Venue,
Id = group.group_key,
AvgLatency = new((long)avgLatency),
Timestamp = args.BeginDate + new TimeSpan(group.group_key * args.Interval!.Value.Ticks),
OrderCount = group.table.state.Count,
Volume = (long)group.table.state.Values.Sum(r => r.Quantity)
};
}
}
public ViewStream? Create(string streamId, IEnumerable<(string? Name, int? Index, object? Value)> args) {
if (SupportedStreams.AvgOrderLatency.IsMatch(streamId)) {
return createOrderLatency(args);
}
return null;
}
public IEnumerable<IDataStreamMetadata> GetSupportedStreams() {
yield return SupportedStreams.AvgOrderLatency;
}
ViewStream? createOrderLatency(IEnumerable<(string? Name, int? Index, object? Value)> args) {
if (!StreamFactoryArgStore.TryGetParams(args, out OrderLatencyStreamParams? sp, out var err)) {
logger.LogInvalidParams("avgOrderLatency", err);
return null;
}
return OrderLatencyStreamFactory.CreateOrderLatencyTables(config, sp, logger)
?.AsViewStream(AvgOrderLatencyRow.Schema);
}
static class SupportedStreams {
public static readonly DataStreamMetadata AvgOrderLatency = new() {
Name = AvgOrderLatencyRow.Schema.tableName
};
}
}