private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.SlackNotificationsJobSettings.LogsConnectionString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "SlackNotificationsJobLogs", consoleLogger),
consoleLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
var azureStorageLogger = new LykkeLogToAzureStorage(persistenceManager, slackNotificationsManager, consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
}
return(aggregateLogger);
}
public void AggregatedLoggerDependantLoggerLogErrorTest2()
{
const int repeats = 10;
var calls = 0;
var mockLogger1 = new Mock <ILogger>();
var mockLogger2 = new Mock <ILogger>();
mockLogger1.Setup(l => l.LogError(It.IsAny <Exception>())).Callback(() => ++ calls);
mockLogger2.Setup(l => l.LogError(It.IsAny <Exception>())).Callback(() => ++ calls);
var tested = new AggregateLogger(new List <ILogger> {
mockLogger1.Object, mockLogger2.Object
});
for (var i = 0; i < repeats;)
{
Assert.Equal(i, calls);
if (i % 2 == 0)
{
mockLogger1.Object.LogError(new ArgumentException());
}
else
{
mockLogger2.Object.LogError(new ArgumentException());
}
Assert.Equal(++i, calls);
}
}
protected override ILogger CreateLogger(TelemetrySession telemetrySession)
=> AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(FunctionIdOptions.CreateFunctionIsEnabledPredicate(_globalOptions)),
TelemetryLogger.Create(telemetrySession, _globalOptions),
new FileLogger(_globalOptions),
Logger.GetLogger());
public void AggregatedLoggerDependantLoggerLogInfoTest()
{
const int repeats = 10;
var calls = 0;
var mockLogger1 = new Mock <ILogger>();
var mockLogger2 = new Mock <ILogger>();
mockLogger1.Setup(l => l.LogInfo(It.IsAny <string>())).Callback(() => ++ calls);
mockLogger2.Setup(l => l.LogInfo(It.IsAny <string>())).Callback(() => ++ calls);
var tested = new AggregateLogger(new List <ILogger> {
mockLogger1.Object, mockLogger2.Object
});
for (var i = 0; i < repeats;)
{
Assert.Equal(i, calls);
if (i % 2 == 0)
{
mockLogger1.Object.LogInfo(string.Empty);
}
else
{
mockLogger2.Object.LogInfo(string.Empty);
}
Assert.Equal(++i, calls);
}
}
private void SetGlobalContext(int uiCultureLCID, int cultureLCID, string serializedSession)
{
var session = new TelemetrySession(serializedSession);
session.Start();
EnsureCulture(uiCultureLCID, cultureLCID);
WatsonReporter.InitializeFatalErrorHandlers(session);
WatsonReporter.InitializeLogger(Logger);
// set roslyn loggers
RoslynServices.SetTelemetrySession(session);
RoslynLogger.SetLogger(AggregateLogger.Create(new VSTelemetryLogger(session), RoslynLogger.GetLogger()));
// start performance reporter
var diagnosticAnalyzerPerformanceTracker = SolutionService.PrimaryWorkspace.Services.GetService <IPerformanceTrackerService>();
if (diagnosticAnalyzerPerformanceTracker != null)
{
var globalOperationNotificationService = SolutionService.PrimaryWorkspace.Services.GetService <IGlobalOperationNotificationService>();
_performanceReporter = new PerformanceReporter(Logger, diagnosticAnalyzerPerformanceTracker, globalOperationNotificationService, s_reportInterval, _shutdownCancellationSource.Token);
}
}
public void AggregatedLoggerCreateTest()
{
var mockLogger1 = new Mock <ILogger>();
var mockLogger2 = new Mock <ILogger>();
var tested = new AggregateLogger(mockLogger1.Object, mockLogger2.Object);
Assert.Equal(2, tested.Loggers.Count);
}
private ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var aggregateLogger = new AggregateLogger();
var consoleLog = new LogToConsole();
aggregateLogger.AddLog(consoleLog);
var dbLogConnectionStringManager = settings.Nested(x => x.TradesConverterJob.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
if (string.IsNullOrEmpty(dbLogConnectionString))
{
consoleLog.WriteWarning(nameof(Startup), nameof(CreateLogWithSlack), "Table loggger is not inited");
return(aggregateLogger);
}
if (dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}"))
{
throw new InvalidOperationException($"LogsConnString {dbLogConnectionString} is not filled in settings");
}
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "TradesConverterLog", consoleLog),
consoleLog);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(
slackService,
new HashSet <string> {
LykkeLogToAzureStorage.ErrorType, LykkeLogToAzureStorage.FatalErrorType, LykkeLogToAzureStorage.MonitorType
},
consoleLog);
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLog);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
var logToSlack = LykkeLogToSlack.Create(slackService, "Bridges", LogLevel.Error | LogLevel.FatalError | LogLevel.Warning);
aggregateLogger.AddLog(logToSlack);
return(aggregateLogger);
}
private static ILog CreateLogWithSlack(IServiceCollection services, IReloadingManager <AppSettings> settings)
{
var consoleLogger = new LogToConsole();
var aggregateLogger = new AggregateLogger();
aggregateLogger.AddLog(consoleLogger);
// Creating slack notification service, which logs own azure queue processing messages to aggregate log
var slackService = services.UseSlackNotificationsSenderViaAzureQueue(new AzureQueueIntegration.AzureQueueSettings
{
ConnectionString = settings.CurrentValue.SlackNotifications.AzureQueue.ConnectionString,
QueueName = settings.CurrentValue.SlackNotifications.AzureQueue.QueueName
}, aggregateLogger);
var dbLogConnectionStringManager = settings.Nested(x => x.BitcoinCashApi.Db.LogsConnString);
var dbLogConnectionString = dbLogConnectionStringManager.CurrentValue;
// Creating azure storage logger, which logs own messages to concole log
if (!string.IsNullOrEmpty(dbLogConnectionString) && !(dbLogConnectionString.StartsWith("${") && dbLogConnectionString.EndsWith("}")))
{
var persistenceManager = new LykkeLogToAzureStoragePersistenceManager(
AzureTableStorage <LogEntity> .Create(dbLogConnectionStringManager, "BitcoinCashApiLog", consoleLogger),
consoleLogger);
var slackNotificationsManager = new LykkeLogToAzureSlackNotificationsManager(slackService, consoleLogger);
var azureStorageLogger = new LykkeLogToAzureStorage(
persistenceManager,
slackNotificationsManager,
consoleLogger);
azureStorageLogger.Start();
aggregateLogger.AddLog(azureStorageLogger);
var allMessagesSlackLogger = LykkeLogToSlack.Create
(
slackService,
"BlockChainIntegration",
// ReSharper disable once RedundantArgumentDefaultValue
LogLevel.All
);
aggregateLogger.AddLog(allMessagesSlackLogger);
var importantMessagesSlackLogger = LykkeLogToSlack.Create
(
slackService,
"BlockChainIntegrationImportantMessages",
LogLevel.All ^ LogLevel.Info
);
aggregateLogger.AddLog(importantMessagesSlackLogger);
}
return(aggregateLogger);
}
public void IsThreadSafeReturnsFalseWhenAnyLoggerIsnt()
{
var mockLogger1 = new Mock <ILogger>();
var mockLogger2 = new Mock <ILogger>();
var mockLogger3 = new Mock <ILogger>();
mockLogger1.SetupGet(m => m.IsThreadSafe).Returns(true);
mockLogger2.SetupGet(m => m.IsThreadSafe).Returns(true);
mockLogger3.SetupGet(m => m.IsThreadSafe).Returns(false);
var tested = new AggregateLogger(mockLogger1.Object, mockLogger2.Object, mockLogger3.Object);
Assert.False(tested.IsThreadSafe);
}
public void IsThreadSafeReturnsWhatAllLogersDo(bool isThreadSafe)
{
var mockLogger1 = new Mock <ILogger>();
var mockLogger2 = new Mock <ILogger>();
var mockLogger3 = new Mock <ILogger>();
mockLogger1.SetupGet(m => m.IsThreadSafe).Returns(isThreadSafe);
mockLogger2.SetupGet(m => m.IsThreadSafe).Returns(isThreadSafe);
mockLogger3.SetupGet(m => m.IsThreadSafe).Returns(isThreadSafe);
var tested = new AggregateLogger(mockLogger1.Object, mockLogger2.Object, mockLogger3.Object);
Assert.Equal(isThreadSafe, tested.IsThreadSafe);
}
public void FlushAutoReturnsFalseWhenAnyLoggerDoesent()
{
var mockLogger1 = new Mock <ILogger>();
var mockLogger2 = new Mock <ILogger>();
var mockLogger3 = new Mock <ILogger>();
mockLogger1.SetupGet(m => m.FlushAuto).Returns(true);
mockLogger2.SetupGet(m => m.FlushAuto).Returns(true);
mockLogger3.SetupGet(m => m.FlushAuto).Returns(false);
var tested = new AggregateLogger(mockLogger1.Object, mockLogger2.Object, mockLogger3.Object);
Assert.False(tested.FlushAuto);
}
public void FlushAutoReturnsWhatAllLogersDo(bool flushesAuto)
{
var mockLogger1 = new Mock <ILogger>();
var mockLogger2 = new Mock <ILogger>();
var mockLogger3 = new Mock <ILogger>();
mockLogger1.SetupGet(m => m.FlushAuto).Returns(flushesAuto);
mockLogger2.SetupGet(m => m.FlushAuto).Returns(flushesAuto);
mockLogger3.SetupGet(m => m.FlushAuto).Returns(flushesAuto);
var tested = new AggregateLogger(mockLogger1.Object, mockLogger2.Object, mockLogger3.Object);
Assert.Equal(flushesAuto, tested.FlushAuto);
}
public static IContainerRegistry UseAggregateLogger(this IContainerRegistry container)
{
return(container.RegisterSingleton <AggregateLogger>(c =>
{
var logger = new AggregateLogger();
var aggregate = (IAggregateLogger)logger;
aggregate.AddLoggers(c.Resolve <IEnumerable <IAggregableLogger> >());
return logger;
})
.Register <IAggregateLogger>(c => c.Resolve <AggregateLogger>())
.Register <ILogger>(c => c.Resolve <AggregateLogger>())
.Register <IAnalyticsService>(c => c.Resolve <AggregateLogger>())
.Register <ICrashesService>(c => c.Resolve <AggregateLogger>()));
}
public void AggregatedLoggerLogWarningTest()
{
var mockLogger1 = new Mock <ILogger>(MockBehavior.Strict);
var mockLogger2 = new Mock <ILogger>(MockBehavior.Strict);
mockLogger1.Setup(l => l.LogWarning(It.IsAny <string>()));
mockLogger2.Setup(l => l.LogWarning(It.IsAny <string>()));
var tested = new AggregateLogger(new List <ILogger> {
mockLogger1.Object, mockLogger2.Object
});
tested.LogWarning("test");
mockLogger1.VerifyAll();
}
public static void Initialize(IServiceProvider serviceProvider, TelemetrySession session)
{
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
var optionService = componentModel.GetService <IGlobalOptionService>();
Logger.SetLogger(
AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(optionService),
new VSTelemetryLogger(session),
Logger.GetLogger()));
Logger.Log(FunctionId.Run_Environment, KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
}
public PerfMarginPanel()
{
Logger.SetLogger(
AggregateLogger.AddOrReplace(
s_logger,
Logger.GetLogger(),
l => l is PerfEventActivityLogger
)
);
// grid
_mainGrid = new Grid();
_mainGrid.ColumnDefinitions.Add(new ColumnDefinition());
_mainGrid.RowDefinitions.Add(new RowDefinition()
{
Height = GridLength.Auto
});
_mainGrid.RowDefinitions.Add(new RowDefinition()
{
Height = GridLength.Auto
});
// set diagnostic list
_mainListView = CreateContent(
new ActivityLevel[] { s_model.RootNode }.Concat(s_model.RootNode.Children),
useWrapPanel: true
);
_mainListView.SelectionChanged += OnPerfItemsListSelectionChanged;
Grid.SetRow(_mainListView, 0);
_mainGrid.Children.Add(_mainListView);
this.Content = _mainGrid;
_timer = new DispatcherTimer(
TimeSpan.FromMilliseconds(500),
DispatcherPriority.Background,
UpdateUI,
this.Dispatcher
);
StartTimer();
s_model.RootNode.IsActiveChanged += (s, e) =>
{
if (_stopTimer)
{
StartTimer();
}
};
}
/// <summary>
/// 创建日志操作实例
/// </summary>
/// <param name="name">日志名称</param>
public ILogger CreateLogger(string name)
{
if (!Loggers.TryGetValue(name, out var logger))
{
lock (_lock)
{
if (!Loggers.TryGetValue(name, out logger))
{
logger = new AggregateLogger(Providers.ToArray(), name);
Loggers[name] = logger;
}
}
}
return(logger);
}
public void TestAllocationPooling()
{
Logger.SetLogger(AggregateLogger.Create(TestLogger.Instance, Logger.GetLogger()));
var block1 = LogBlock();
var block2 = LogBlock();
Assert.NotEqual(block1, block2);
block1.Dispose();
var block3 = LogBlock();
Assert.Same(block1, block3);
block2.Dispose();
block3.Dispose();
}
