public SiloStatisticsManager(SiloInitializationParameters initializationParams, SerializationManager serializationManager, ITelemetryProducer telemetryProducer, ILoggerFactory loggerFactory)
{
MessagingStatisticsGroup.Init(true);
MessagingProcessingStatisticsGroup.Init();
NetworkingStatisticsGroup.Init(true);
ApplicationRequestsStatisticsGroup.Init(initializationParams.ClusterConfig.Globals.ResponseTimeout);
SchedulerStatisticsGroup.Init(loggerFactory);
StorageStatisticsGroup.Init();
TransactionsStatisticsGroup.Init();
this.logger = new LoggerWrapper <SiloStatisticsManager>(loggerFactory);
runtimeStats = new RuntimeStatisticsGroup(loggerFactory);
this.logStatistics = new LogStatistics(initializationParams.NodeConfig.StatisticsLogWriteInterval, true, serializationManager, loggerFactory);
this.MetricsTable = new SiloPerformanceMetrics(this.runtimeStats, loggerFactory, initializationParams.NodeConfig);
this.countersPublisher = new CountersStatistics(initializationParams.NodeConfig.StatisticsPerfCountersWriteInterval, telemetryProducer, loggerFactory);
initializationParams.ClusterConfig.OnConfigChange(
"Defaults/LoadShedding",
() => this.MetricsTable.NodeConfig = initializationParams.NodeConfig,
false);
}
public SiloStatisticsManager(
IOptions <SiloStatisticsOptions> statisticsOptions,
IOptions <MonitoringStorageOptions> azureStorageOptions,
ILocalSiloDetails siloDetails,
SerializationManager serializationManager,
ITelemetryProducer telemetryProducer,
ILoggerFactory loggerFactory)
{
this.siloDetails = siloDetails;
this.storageOptions = azureStorageOptions.Value;
MessagingStatisticsGroup.Init(true);
MessagingProcessingStatisticsGroup.Init();
NetworkingStatisticsGroup.Init(true);
ApplicationRequestsStatisticsGroup.Init();
SchedulerStatisticsGroup.Init(loggerFactory);
StorageStatisticsGroup.Init();
TransactionsStatisticsGroup.Init();
this.logger = loggerFactory.CreateLogger <SiloStatisticsManager>();
this.logStatistics = new LogStatistics(statisticsOptions.Value.LogWriteInterval, true, serializationManager, loggerFactory);
this.countersPublisher = new CountersStatistics(statisticsOptions.Value.PerfCountersWriteInterval, telemetryProducer, loggerFactory);
}
public SiloStatisticsManager(
NodeConfiguration nodeConfiguration,
ILocalSiloDetails siloDetails,
SerializationManager serializationManager,
ITelemetryProducer telemetryProducer,
IHostEnvironmentStatistics hostEnvironmentStatistics,
IAppEnvironmentStatistics appEnvironmentStatistics,
ILoggerFactory loggerFactory,
IOptions <MessagingOptions> messagingOptions)
{
this.siloDetails = siloDetails;
MessagingStatisticsGroup.Init(true);
MessagingProcessingStatisticsGroup.Init();
NetworkingStatisticsGroup.Init(true);
ApplicationRequestsStatisticsGroup.Init(messagingOptions.Value.ResponseTimeout);
SchedulerStatisticsGroup.Init(loggerFactory);
StorageStatisticsGroup.Init();
TransactionsStatisticsGroup.Init();
this.logger = loggerFactory.CreateLogger <SiloStatisticsManager>();
this.hostEnvironmentStatistics = hostEnvironmentStatistics;
this.logStatistics = new LogStatistics(nodeConfiguration.StatisticsLogWriteInterval, true, serializationManager, loggerFactory);
this.MetricsTable = new SiloPerformanceMetrics(this.hostEnvironmentStatistics, appEnvironmentStatistics, loggerFactory, nodeConfiguration);
this.countersPublisher = new CountersStatistics(nodeConfiguration.StatisticsPerfCountersWriteInterval, telemetryProducer, loggerFactory);
}
private void ReceiveMessage(Message msg)
{
MessagingProcessingStatisticsGroup.OnImaMessageReceived(msg);
ISchedulingContext context;
// Find the activation it targets; first check for a system activation, then an app activation
if (msg.TargetGrain.IsSystemTarget)
{
SystemTarget target = directory.FindSystemTarget(msg.TargetActivation);
if (target == null)
{
MessagingStatisticsGroup.OnRejectedMessage(msg);
Message response = this.messageFactory.CreateRejectionResponse(msg, Message.RejectionTypes.Unrecoverable,
String.Format("SystemTarget {0} not active on this silo. Msg={1}", msg.TargetGrain, msg));
messageCenter.SendMessage(response);
Log.Warn(ErrorCode.MessagingMessageFromUnknownActivation, "Received a message {0} for an unknown SystemTarget: {1}", msg, msg.TargetAddress);
return;
}
context = target.SchedulingContext;
switch (msg.Direction)
{
case Message.Directions.Request:
MessagingProcessingStatisticsGroup.OnImaMessageEnqueued(context);
scheduler.QueueWorkItem(new RequestWorkItem(target, msg), context);
break;
case Message.Directions.Response:
MessagingProcessingStatisticsGroup.OnImaMessageEnqueued(context);
scheduler.QueueWorkItem(new ResponseWorkItem(target, msg), context);
break;
default:
Log.Error(ErrorCode.Runtime_Error_100097, "Invalid message: " + msg);
break;
}
}
else
{
// Run this code on the target activation's context, if it already exists
ActivationData targetActivation = directory.FindTarget(msg.TargetActivation);
if (targetActivation != null)
{
lock (targetActivation)
{
var target = targetActivation; // to avoid a warning about nulling targetActivation under a lock on it
if (target.State == ActivationState.Valid)
{
var overloadException = target.CheckOverloaded(Log);
if (overloadException != null)
{
// Send rejection as soon as we can, to avoid creating additional work for runtime
dispatcher.RejectMessage(msg, Message.RejectionTypes.Overloaded, overloadException, "Target activation is overloaded " + target);
return;
}
// Run ReceiveMessage in context of target activation
context = new SchedulingContext(target);
}
else
{
// Can't use this activation - will queue for another activation
target = null;
context = null;
}
EnqueueReceiveMessage(msg, target, context);
}
}
else
{
// No usable target activation currently, so run ReceiveMessage in system context
EnqueueReceiveMessage(msg, null, null);
}
}
}
