public void Does_not_report_when_nothing_to_report()
{
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, _logManager);
MakeTimePass();
localStats.ReportCall("A", 300, true);
_testLogger.LogList.Should().HaveCount(0);
}
public void Single_average_is_fine()
{
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, _logManager);
localStats.ReportCall("A", 100, true);
MakeTimePass();
localStats.ReportCall("A", 300, true);
CheckLogLine("A|1|100|100|0|0|0|");
CheckLogLine("TOTAL|1|100|100|0|0|0|");
}
public void Calls_do_not_delay_report()
{
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, _logManager);
for (int i = 0; i < 100; i++)
{
localStats.ReportCall("A", 300, true);
MakeTimePass(60);
}
_testLogger.LogList.Should().HaveCountGreaterThan(0);
}
public void Orders_alphabetically()
{
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, _logManager);
localStats.ReportCall("C", 1, true);
localStats.ReportCall("A", 2, true);
localStats.ReportCall("B", 3, false);
MakeTimePass();
localStats.ReportCall("A", 300, true);
_testLogger.LogList[0].IndexOf("A ", StringComparison.InvariantCulture).Should().BeLessThan(_testLogger.LogList[0].IndexOf("B ", StringComparison.InvariantCulture));
_testLogger.LogList[0].IndexOf("B ", StringComparison.InvariantCulture).Should().BeLessThan(_testLogger.LogList[0].IndexOf("C ", StringComparison.InvariantCulture));
}
public void Does_not_report_when_info_not_enabled()
{
_testLogger = new TestLogger();
_testLogger.IsInfo = false;
OneLoggerLogManager logManager = new OneLoggerLogManager(_testLogger);
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, logManager);
localStats.ReportCall("A", 100, true);
MakeTimePass();
localStats.ReportCall("A", 300, true);
_testLogger.LogList.Should().HaveCount(0);
}
public void Single_of_each_is_fine()
{
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, _logManager);
localStats.ReportCall("A", 25, true);
localStats.ReportCall("A", 125, false);
localStats.ReportCall("B", 75, true);
localStats.ReportCall("B", 175, false);
MakeTimePass();
localStats.ReportCall("A", 300, true);
CheckLogLine("A|1|25|25|1|125|125|");
CheckLogLine("B|1|75|75|1|175|175|");
CheckLogLine("TOTAL|2|50|75|2|150|175|");
}
public void Multiple_have_no_decimal_places()
{
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, _logManager);
localStats.ReportCall("A", 30, true);
localStats.ReportCall("A", 20, true);
localStats.ReportCall("A", 50, true);
localStats.ReportCall("A", 60, false);
localStats.ReportCall("A", 40, false);
localStats.ReportCall("A", 100, false);
MakeTimePass();
localStats.ReportCall("A", 300, true);
CheckLogLine("A|3|33|50|3|67|100|");
CheckLogLine("TOTAL|3|33|50|3|67|100|");
}
public void Swaps_properly()
{
JsonRpcLocalStats localStats = new JsonRpcLocalStats(_manualTimestamper, _config, _logManager);
localStats.ReportCall("A", 100, true);
MakeTimePass();
localStats.ReportCall("A", 300, true);
CheckLogLine("A|1|100|100|0|0|0|");
_testLogger.LogList.Clear();
MakeTimePass();
localStats.ReportCall("A", 500, true);
CheckLogLine("A|1|300|300|0|0|0|");
_testLogger.LogList.Clear();
MakeTimePass();
localStats.ReportCall("A", 700, true);
CheckLogLine("A|1|500|500|0|0|0|");
_testLogger.LogList.Clear();
}
public async Task Execute(CancellationToken cancellationToken)
{
IJsonRpcConfig jsonRpcConfig = _api.Config <IJsonRpcConfig>();
ILogger logger = _api.LogManager.GetClassLogger();
if (jsonRpcConfig.Enabled)
{
IInitConfig initConfig = _api.Config <IInitConfig>();
JsonRpcLocalStats jsonRpcLocalStats = new JsonRpcLocalStats(
_api.Timestamper,
jsonRpcConfig,
_api.LogManager);
JsonRpcService jsonRpcService = new JsonRpcService(_api.RpcModuleProvider, _api.LogManager);
JsonRpcProcessor jsonRpcProcessor = new JsonRpcProcessor(
jsonRpcService,
_api.EthereumJsonSerializer,
jsonRpcConfig,
_api.FileSystem,
_api.LogManager);
if (initConfig.WebSocketsEnabled)
{
// TODO: I do not like passing both service and processor to any of the types
JsonRpcWebSocketsModule?webSocketsModule = new JsonRpcWebSocketsModule(
jsonRpcProcessor,
jsonRpcService,
_api.EthereumJsonSerializer,
jsonRpcLocalStats);
_api.WebSocketsManager !.AddModule(webSocketsModule, true);
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = _api.LogManager;
Bootstrap.Instance.JsonSerializer = _api.EthereumJsonSerializer;
Bootstrap.Instance.JsonRpcLocalStats = jsonRpcLocalStats;
var jsonRpcRunner = new JsonRpcRunner(
jsonRpcProcessor,
_api.WebSocketsManager,
_api.ConfigProvider,
_api.LogManager,
_api);
await jsonRpcRunner.Start(cancellationToken).ContinueWith(x =>
{
if (x.IsFaulted && logger.IsError)
{
logger.Error("Error during jsonRpc runner start", x.Exception);
}
});
_api.DisposeStack.Push(Disposable.Create(() => jsonRpcRunner.StopAsync())); // do not await
}
else
{
if (logger.IsInfo)
{
logger.Info("Json RPC is disabled");
}
}
}
protected async Task StartRunners(CancellationToken cancellationToken, IConfigProvider configProvider)
{
IFileSystem fileSystem = new FileSystem();
IInitConfig initConfig = configProvider.GetConfig <IInitConfig>();
IJsonRpcConfig jsonRpcConfig = configProvider.GetConfig <IJsonRpcConfig>();
IMetricsConfig metricsConfig = configProvider.GetConfig <IMetricsConfig>();
ISeqConfig seqConfig = configProvider.GetConfig <ISeqConfig>();
NLogManager logManager = new NLogManager(initConfig.LogFileName, initConfig.LogDirectory);
IRpcModuleProvider rpcModuleProvider = jsonRpcConfig.Enabled
? new RpcModuleProvider(fileSystem, configProvider.GetConfig <IJsonRpcConfig>(), logManager)
: (IRpcModuleProvider)NullModuleProvider.Instance;
EthereumJsonSerializer jsonSerializer = new EthereumJsonSerializer();
WebSocketsManager webSocketsManager = new WebSocketsManager();
JsonRpcLocalStats jsonRpcLocalStats = new JsonRpcLocalStats(Timestamper.Default, jsonRpcConfig, logManager);
if (seqConfig.MinLevel != "Off")
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info($"Seq Logging enabled on host: {seqConfig.ServerUrl} with level: {seqConfig.MinLevel}");
}
new NLogConfigurator().ConfigureSeqBufferTarget(seqConfig.ServerUrl, seqConfig.ApiKey, seqConfig.MinLevel);
}
if (!string.IsNullOrEmpty(metricsConfig.NodeName))
{
logManager.SetGlobalVariable("nodeName", metricsConfig.NodeName);
}
if (metricsConfig.Enabled)
{
Metrics.Version = VersionToMetrics.ConvertToNumber(ClientVersion.Version);
MetricsUpdater metricsUpdater = new MetricsUpdater(metricsConfig);
_monitoringService = new MonitoringService(metricsUpdater, metricsConfig, logManager);
_monitoringService.RegisterMetrics(typeof(Nethermind.Blockchain.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Db.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Evm.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.JsonRpc.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Trie.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Network.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Synchronization.Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.TxPool.Metrics));
_monitoringService.RegisterMetrics(typeof(Metrics));
_monitoringService.RegisterMetrics(typeof(Nethermind.Consensus.AuRa.Metrics));
await _monitoringService.StartAsync().ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during starting a monitoring.", x.Exception);
}
}, cancellationToken);
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Grafana / Prometheus metrics are disabled in configuration");
}
}
IGrpcConfig grpcConfig = configProvider.GetConfig <IGrpcConfig>();
GrpcServer? grpcServer = null;
if (grpcConfig.Enabled)
{
grpcServer = new GrpcServer(jsonSerializer, logManager);
_grpcRunner = new GrpcRunner(grpcServer, grpcConfig, logManager);
await _grpcRunner.Start(cancellationToken).ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during GRPC runner start", x.Exception);
}
});
}
INdmDataPublisher? ndmDataPublisher = null;
INdmConsumerChannelManager?ndmConsumerChannelManager = null;
INdmInitializer? ndmInitializer = null;
INdmConfig ndmConfig = configProvider.GetConfig <INdmConfig>();
bool ndmEnabled = ndmConfig.Enabled;
if (ndmEnabled)
{
ndmDataPublisher = new NdmDataPublisher();
ndmConsumerChannelManager = new NdmConsumerChannelManager();
string initializerName = ndmConfig.InitializerName;
if (_logger?.IsInfo ?? false)
{
_logger !.Info($"NDM initializer: {initializerName}");
}
Type ndmInitializerType = AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetTypes())
.FirstOrDefault(t =>
t.GetCustomAttribute <NdmInitializerAttribute>()?.Name == initializerName);
NdmModule ndmModule = new NdmModule();
NdmConsumersModule ndmConsumersModule = new NdmConsumersModule();
ndmInitializer =
new NdmInitializerFactory(ndmInitializerType, ndmModule, ndmConsumersModule, logManager)
.CreateOrFail();
if (grpcServer != null)
{
ndmConsumerChannelManager.Add(new GrpcNdmConsumerChannel(grpcServer));
}
NdmWebSocketsModule ndmWebSocketsModule =
new NdmWebSocketsModule(ndmConsumerChannelManager, ndmDataPublisher, jsonSerializer);
webSocketsManager.AddModule(ndmWebSocketsModule);
}
_ethereumRunner = new EthereumRunner(
rpcModuleProvider,
configProvider,
logManager,
grpcServer,
ndmConsumerChannelManager,
ndmDataPublisher,
ndmInitializer,
webSocketsManager,
jsonSerializer,
_monitoringService);
IAnalyticsConfig analyticsConfig = configProvider.GetConfig <IAnalyticsConfig>();
if (analyticsConfig.PluginsEnabled ||
analyticsConfig.StreamBlocks ||
analyticsConfig.StreamTransactions)
{
webSocketsManager.AddModule(new AnalyticsWebSocketsModule(jsonSerializer), true);
}
await _ethereumRunner.Start(cancellationToken).ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during ethereum runner start", x.Exception);
}
});
if (jsonRpcConfig.Enabled)
{
rpcModuleProvider.Register(new SingletonModulePool <IWeb3Module>(new Web3Module(logManager), true));
JsonRpcService jsonRpcService = new JsonRpcService(rpcModuleProvider, logManager);
JsonRpcProcessor jsonRpcProcessor =
new JsonRpcProcessor(jsonRpcService, jsonSerializer, jsonRpcConfig, fileSystem, logManager);
if (initConfig.WebSocketsEnabled)
{
webSocketsManager.AddModule(
new JsonRpcWebSocketsModule(jsonRpcProcessor, jsonRpcService, jsonSerializer, jsonRpcLocalStats), true);
}
Bootstrap.Instance.JsonRpcService = jsonRpcService;
Bootstrap.Instance.LogManager = logManager;
Bootstrap.Instance.JsonSerializer = jsonSerializer;
Bootstrap.Instance.JsonRpcLocalStats = jsonRpcLocalStats;
_jsonRpcRunner = new JsonRpcRunner(
configProvider,
rpcModuleProvider,
logManager,
jsonRpcProcessor,
webSocketsManager);
await _jsonRpcRunner.Start(cancellationToken).ContinueWith(x =>
{
if (x.IsFaulted && (_logger?.IsError ?? false))
{
_logger !.Error("Error during jsonRpc runner start", x.Exception);
}
});
}
else
{
if (_logger?.IsInfo ?? false)
{
_logger !.Info("Json RPC is disabled");
}
}
}
