private void ReportMemoryUsage()
{
try
{
var process = System.Diagnostics.Process.GetCurrentProcess();
_telemetry.Publish <ProcessPrivateMemorySizeIdentity>(process.PrivateMemorySize64);
_telemetry.Publish <ProcessWorkingSetIdentity>(process.WorkingSet64);
}
catch (Exception)
{
}
}
private StageResult Handle(Guid bucketId, IEnumerable <IAggregatableMessage> messages)
{
try
{
foreach (var message in messages.OfType <OperationAggregatableMessage <AggregateOperation> >())
{
_aggregatesConstructor.Execute(message.Operations);
_telemetryPublisher.Publish <AggregateProcessedOperationCountIdentity>(message.Operations.Count);
_telemetryPublisher.Publish <AggregateProcessingDelayIdentity>((long)(DateTime.UtcNow - message.OperationTime).TotalMilliseconds);
}
return(MessageProcessingStage.Handling.ResultFor(bucketId).AsSucceeded());
}
catch (Exception ex)
{
_tracer.Error(ex, "Error when calculating aggregates");
return(MessageProcessingStage.Handling.ResultFor(bucketId).AsFailed().WithExceptions(ex));
}
}
public IReadOnlyList <IMessage> Peek()
{
using (Probe.Create("Peek Erm Operations"))
{
var messages = _receiver.Peek();
var serviceBusMessageCount = messages.Cast <ServiceBusPerformedOperationsMessage>().Sum(x => x.Operations.Count());
_telemetryPublisher.Publish <ErmReceivedUseCaseCountIdentity>(serviceBusMessageCount);
return(messages);
}
}
public IEnumerable <StageResult> Handle(IReadOnlyDictionary <Guid, List <IAggregatableMessage> > processingResultsMap)
{
try
{
var messages = processingResultsMap.SelectMany(pair => pair.Value)
.Cast <OperationAggregatableMessage <FactOperation> >()
.ToArray();
Handle(messages.SelectMany(message => message.Operations).ToArray());
var eldestOperationPerformTime = messages.Min(message => message.OperationTime);
_telemetryPublisher.Publish <PrimaryProcessingDelayIdentity>((long)(DateTime.UtcNow - eldestOperationPerformTime).TotalMilliseconds);
return(processingResultsMap.Keys.Select(bucketId => MessageProcessingStage.Handling.ResultFor(bucketId).AsSucceeded()));
}
catch (Exception ex)
{
_tracer.Error(ex, "Error when import facts for ERM");
return(processingResultsMap.Keys.Select(bucketId => MessageProcessingStage.Handling.ResultFor(bucketId).AsFailed().WithExceptions(ex)));
}
}
protected override OperationAggregatableMessage <FactOperation> Process(TrackedUseCase message)
{
_tracer.DebugFormat("Processing TUC {0}", message.Id);
var receivedOperationCount = message.Operations.Sum(x => x.AffectedEntities.Changes.Sum(y => y.Value.Sum(z => z.Value.Count)));
_telemetryPublisher.Publish <ErmReceivedOperationCountIdentity>(receivedOperationCount);
var changes = _useCaseFiltrator.Filter(message);
// TODO: вместо кучи factoperation можно передавать одну с dictionary, где уже всё сгруппировано по entity type
var factOperations = changes.SelectMany(x => x.Value.Select(y => new FactOperation(_registry.GetEntityType(x.Key), y))).ToList();
_telemetryPublisher.Publish <ErmEnqueuedOperationCountIdentity>(factOperations.Count);
return(new OperationAggregatableMessage <FactOperation>
{
TargetFlow = MessageFlow,
Operations = factOperations,
OperationTime = message.Context.Finished.UtcDateTime,
});
}
private StageResult Handle(Guid bucketId, IEnumerable <IAggregatableMessage> messages)
{
try
{
foreach (var message in messages.OfType <CorporateBusAggregatableMessage>())
{
foreach (var dto in message.Dtos)
{
var importer = _statisticsImporterFactory.Create(dto.GetType());
var opertaions = importer.Import(dto);
_telemetryPublisher.Publish <BitStatisticsEntityProcessedCountIdentity>(1);
_sender.Push(opertaions.Cast <RecalculateStatisticsOperation>());
}
}
return(MessageProcessingStage.Handling.ResultFor(bucketId).AsSucceeded());
}
catch (Exception ex)
{
_tracer.Error(ex, "Error when import facts for BIT");
return(MessageProcessingStage.Handling.ResultFor(bucketId).AsFailed().WithExceptions(ex));
}
}