public static void Main(string[] args)
{
try
{
ThreadPool.SetMinThreads(10000, 500);
ServicePointManager.DefaultConnectionLimit = int.MaxValue;
ServicePointManager.UseNagleAlgorithm = false;
ServicePointManager.Expect100Continue = false;
LoggingSource.Initialize(ServiceEventSource.Current.Message);
ServiceRuntime.RegisterServiceAsync(
"StockServiceType",
context =>
new StockService(context)).GetAwaiter().GetResult();
ServiceEventSource.Current.ServiceTypeRegistered(Process.GetCurrentProcess().Id, typeof(StockService).Name);
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// 这是服务主机进程的入口点。
/// </summary>
private static void Main()
{
try
{
// ServiceManifest.XML 文件定义一个或多个服务类型名称。
// 注册服务会将服务类型名称映射到 .NET 类型。
// 在 Service Fabric 创建此服务类型的实例时，
// 会在此主机进程中创建类的实例。
ThreadPool.SetMinThreads(10000, 500);//线程池 最小
ServicePointManager.DefaultConnectionLimit = int.MaxValue;
ServicePointManager.UseNagleAlgorithm = false;
ServicePointManager.Expect100Continue = false;
LoggingSource.Initialize(ServiceEventSource.Current.Message);
ServiceRuntime.RegisterServiceAsync("PublicGateType",
context => new PublicGate(context)).GetAwaiter().GetResult();
ServiceEventSource.Current.ServiceTypeRegistered(Process.GetCurrentProcess().Id, typeof(PublicGate).Name);
// 防止此主机进程终止，以使服务保持运行。
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceHostInitializationFailed(e.ToString());
throw;
}
}
public async Task LoggingSource_WhileLogging_ShouldNotLoseLogFile(bool compressing)
{
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
var retentionTime = TimeSpan.MaxValue;
var retentionSize = long.MaxValue;
var loggingSource = new LoggingSource(
LogMode.Information,
path,
"LoggingSource" + name,
retentionTime,
retentionSize,
compressing);
loggingSource.MaxFileSizeInBytes = 1024;
//This is just to make sure the MaxFileSizeInBytes is get action for the first file
loggingSource.SetupLogMode(LogMode.Operations, path, retentionTime, retentionSize, compressing);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
for (var i = 0; i < 1000; i++)
{
await logger.OperationsAsync("Some message");
}
var beforeEndFiles = Directory.GetFiles(path);
loggingSource.EndLogging();
var afterEndFiles = Directory.GetFiles(path);
AssertNoFileMissing(beforeEndFiles);
AssertNoFileMissing(afterEndFiles);
}
public static void WriteLogEvent(LoggingSource Source, string ClassMethod, string Message,
LoggingOperationType OperationType, LoggingLevel Level,
Nullable <Guid> IdArchive, Nullable <Guid> IdStorage, Nullable <Guid> IdCorrelation)
{
WriteLogEvent(Source, ClassMethod, Message,
OperationType, Level,
IdArchive, IdStorage, IdCorrelation, Dns.GetHostName(), string.Empty);
}
public static void WriteLogEvent(LoggingSource Source, string ClassMethod, string Message,
LoggingOperationType OperationType, LoggingLevel Level,
Nullable <Guid> IdArchive, Nullable <Guid> IdStorage, Nullable <Guid> IdCorrelation, string Server, String Client)
{
try
{
switch (Level)
{
case LoggingLevel.BiblosDS_Information:
case LoggingLevel.BiblosDS_Trace:
#if DEBUG
EventLogHelper.GetUniqueInstance.Write("Source : " + Source.ToString() +
" ClassMethod : " + ClassMethod +
"\nMessage : " + Message, System.Diagnostics.EventLogEntryType.Information);
#endif
break;
default:
case LoggingLevel.BiblosDS_Warning:
case LoggingLevel.BiblosDS_Managed_Error:
EventLogHelper.GetUniqueInstance.Write("Source : " + Source.ToString() +
" ClassMethod : " + ClassMethod +
"\nMessage : " + Message, System.Diagnostics.EventLogEntryType.Warning);
break;
case LoggingLevel.BiblosDS_Errors:
EventLogHelper.GetUniqueInstance.Write("Source : " + Source.ToString() +
" ClassMethod : " + ClassMethod +
"\nMessage : " + Message, System.Diagnostics.EventLogEntryType.Error);
break;
}
}
catch (Exception)
{
//Ignore
}
try
{
if (ClassMethod.Contains("ConnectionString") == false)
{
// scrive nel database
DbProvider.AddLog(OperationType,
Guid.NewGuid(),
IdArchive == null ? Guid.Empty : (Guid)IdArchive,
IdStorage == null ? Guid.Empty : (Guid)IdStorage,
IdCorrelation == null ? Guid.Empty : (Guid)IdCorrelation,
Message, Server, Client);
}
}
catch (Exception)
{
//Ignore
}
}
public static void WriteLogEvent(LoggingSource Source, string ClassMethod, string Message, LoggingOperationType OperationType, LoggingLevel Level)
{
try
{
WriteLogEvent(Source, ClassMethod, Message, OperationType, Level, null, null, null);
}
catch
{
//PUT into Try to avoid exceptions on the call
}
}
public static void WriteJournaling(LoggingSource Source, string ClassMethod, string Message,
LoggingOperationType OperationType, LoggingLevel Level, Nullable <Guid> IdCorrelation, Document document)
{
if (document == null)
{
document = new Document();
}
WriteJournaling(Source, "", ClassMethod, Message, LoggingOperationType.BiblosDS_General, Level,
document.Archive == null ? Guid.Empty : document.Archive.IdArchive,
document.Storage == null ? Guid.Empty : document.Storage.IdStorage, IdCorrelation);
}
public async Task LoggingSource_WhenExistFileFromToday_ShouldIncrementNumberByOne(string extension)
{
const int fileSize = Constants.Size.Kilobyte;
var testName = GetTestName();
var path = NewDataPath(forceCreateDir: true);
path = Path.Combine(path, Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(path);
const long retentionSize = long.MaxValue;
var retentionTimeConfiguration = TimeSpan.FromDays(3);
var now = DateTime.Now;
var existLog = Path.Combine(path, $"{LoggingSource.LogInfo.DateToLogFormat(now)}.010.{extension}");
await using (var file = File.Create(existLog))
{
file.SetLength(fileSize);
}
var loggingSource = new LoggingSource(
LogMode.Information,
path,
"LoggingSource" + testName,
retentionTimeConfiguration,
retentionSize)
{
MaxFileSizeInBytes = fileSize
};
//This is just to make sure the MaxFileSizeInBytes is get action for the first file
loggingSource.SetupLogMode(LogMode.Operations, path, retentionTimeConfiguration, retentionSize, false);
var logger = new Logger(loggingSource, "Source" + testName, "Logger" + testName);
await logger.OperationsAsync("Some message");
var result = WaitForValue(() =>
{
var strings = Directory.GetFiles(path);
return(strings.Any(f =>
{
if (LoggingSource.LogInfo.TryGetDate(f, out var d) == false || d.Date.Equals(DateTime.Today) == false)
{
return false;
}
return LoggingSource.LogInfo.TryGetNumber(f, out var n) && n == 11;
}));
}, true, 10_000, 1_000);
Assert.True(result);
loggingSource.EndLogging();
}
public static void WriteError(LoggingSource Source, string ClassMethod, Exception ex, LoggingOperationType OperationType, Document document)
{
try
{
WriteLogEvent(Source, ClassMethod, ex.ToString(), OperationType, LoggingLevel.BiblosDS_Errors, document.Archive == null ? Guid.Empty : document.Archive.IdArchive, document.Storage == null ? Guid.Empty : document.Storage.IdStorage, null);
}
catch
{
//PUT into Try to avoid exceptions on the call
}
}
public async Task LoggingSource_WhileRetentionBySizeOn_ShouldKeepRetentionPolicy(bool compressing)
{
const int fileSize = Constants.Size.Kilobyte;
const int retentionSize = 5 * Constants.Size.Kilobyte;
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
var retentionTime = TimeSpan.MaxValue;
var loggingSource = new LoggingSource(
LogMode.Information,
path,
"LoggingSource" + name,
retentionTime,
retentionSize,
compressing);
loggingSource.MaxFileSizeInBytes = fileSize;
//This is just to make sure the MaxFileSizeInBytes is get action for the first file
loggingSource.SetupLogMode(LogMode.Operations, path, retentionTime, retentionSize, compressing);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
for (var i = 0; i < 100; i++)
{
for (var j = 0; j < 5; j++)
{
await logger.OperationsAsync("Some message");
}
Thread.Sleep(10);
}
const int threshold = 2 * fileSize;
long size = 0;
string[] afterEndFiles = null;
var isRetentionPolicyApplied = WaitForValue(() =>
{
Task.Delay(TimeSpan.FromSeconds(1));
afterEndFiles = Directory.GetFiles(path);
AssertNoFileMissing(afterEndFiles);
size = afterEndFiles.Select(f => new FileInfo(f)).Sum(f => f.Length);
return(Math.Abs(size - retentionSize) <= threshold);
}, true, 10_000, 1_000);
Assert.True(isRetentionPolicyApplied,
$"ActualSize({size}), retentionSize({retentionSize}), threshold({threshold})" +
Environment.NewLine +
JustFileNamesAsString(afterEndFiles));
loggingSource.EndLogging();
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
LoggingSource loggingSource = LoggingSource.Instance;
loggingSource.EnableConsoleLogging();
Logger logger = loggingSource.GetLogger <App>("APP");
logger.Info("APPLICATION STARTED");
}
public static void Log(LoggingSource source, string text)
{
string prefixedText = string.Format("{0} [{1}] - {2}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), source, text);
if (sourcesToWriteToDebug.Contains(source))
{
Debug.WriteLine(prefixedText);
}
if (sourcesToWriteToFile.Contains(source))
{
VerifyAppFolderExists();
File.AppendAllText(string.Format(Constants.ApplicationGenericFilePath, "errorlog.txt"), prefixedText);
}
}
public async Task Register_WhenLogModeIsNone_ShouldNotWriteToLogFile()
{
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
path = Path.Combine(path, Guid.NewGuid().ToString());
Directory.CreateDirectory(path);
var loggingSource = new LoggingSource(
LogMode.None,
path,
"LoggingSource" + name,
TimeSpan.MaxValue,
long.MaxValue,
false);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
var tcs = new TaskCompletionSource <WebSocketReceiveResult>(TaskCreationOptions.RunContinuationsAsynchronously);
var socket = new DummyWebSocket();
socket.ReceiveAsyncFunc = () => tcs.Task;
var context = new LoggingSource.WebSocketContext();
var _ = loggingSource.Register(socket, context, CancellationToken.None);
var uniqForOperation = Guid.NewGuid().ToString();
var uniqForInformation = Guid.NewGuid().ToString();
var logTasks = Task.WhenAll(logger.OperationsAsync(uniqForOperation), logger.InfoAsync(uniqForInformation));
var timeout = TimeSpan.FromSeconds(10);
await Task.WhenAny(logTasks, Task.Delay(timeout));
Assert.True(logTasks.IsCompleted, $"Waited over {timeout.TotalSeconds} seconds for log tasks to finish");
tcs.SetResult(new WebSocketReceiveResult(1, WebSocketMessageType.Text, true, WebSocketCloseStatus.NormalClosure, ""));
loggingSource.EndLogging();
Assert.Contains(uniqForOperation, socket.LogsReceived);
Assert.Contains(uniqForInformation, socket.LogsReceived);
var logFile = Directory.GetFiles(path).First();
var logContent = await File.ReadAllTextAsync(logFile);
Assert.DoesNotContain(uniqForOperation, logContent);
Assert.DoesNotContain(uniqForInformation, logContent);
}
public async Task LoggingSource_WhenExistFileFromYesterdayAndCreateNewFileForToday_ShouldResetNumberToZero(string extension)
{
var testName = GetTestName();
var path = NewDataPath(forceCreateDir: true);
path = Path.Combine(path, Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(path);
const long retentionSize = long.MaxValue;
var retentionTimeConfiguration = TimeSpan.FromDays(3);
var yesterday = DateTime.Now - TimeSpan.FromDays(1);
var yesterdayLog = Path.Combine(path, $"{LoggingSource.LogInfo.DateToLogFormat(yesterday)}.010.{extension}");
await File.Create(yesterdayLog).DisposeAsync();
File.SetLastWriteTime(yesterdayLog, yesterday);
var loggingSource = new LoggingSource(
LogMode.Information,
path,
"LoggingSource" + testName,
retentionTimeConfiguration,
retentionSize);
var logger = new Logger(loggingSource, "Source" + testName, "Logger" + testName);
await logger.OperationsAsync("Some message");
var todayLog = string.Empty;
WaitForValue(() =>
{
var afterEndFiles = Directory.GetFiles(path);
todayLog = afterEndFiles.FirstOrDefault(f =>
LoggingSource.LogInfo.TryGetDate(f, out var date) && date.Date.Equals(DateTime.Today));
return(todayLog != null);
}, true, 10_000, 1_000);
Assert.True(LoggingSource.LogInfo.TryGetNumber(todayLog, out var n) && n == 0);
loggingSource.EndLogging();
}
public ActionResult MinimumLevel(LoggingSource loggingSource, LogEventLevel newMiniumLevel)
{
this.logger.LogTrace("LogController: MinimumLevel PUT called");
switch (loggingSource)
{
case LoggingSource.General:
this.appLoggingLevelSwitch.GerneralLoggingLevelSwitch.MinimumLevel = newMiniumLevel;
break;
case LoggingSource.Microsoft:
this.appLoggingLevelSwitch.MicrosoftLoggingLevelSwitch.MinimumLevel = newMiniumLevel;
break;
case LoggingSource.Client:
this.appLoggingLevelSwitch.ClientLoggingLevelSwitch.MinimumLevel = newMiniumLevel;
break;
}
return(base.NoContent());
}
public static void Main(string[] args)
{
try
{
// Initializing ILogger 111
LoggingSource.Initialize(ServiceEventSource.Current.Message);
ServiceRuntime.RegisterServiceAsync(
"StockAggregatorServiceType",
context =>
new StockAggregatorService(context)).GetAwaiter().GetResult();
ServiceEventSource.Current.ServiceTypeRegistered(Process.GetCurrentProcess().Id, typeof(StockAggregatorService).Name);
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ServiceEventSource.Current.ServiceHostInitializationFailed(e.ToString());
throw;
}
}
public static void RemoteMessage(LoggingSource loggingSource,
LoggingType loggingType,
string message,
params object[] args)
{
string formattedMessage = string.Format(message, args);
bool isSuccess;
if ((loggingSource & LoggingSource.Mail) == LoggingSource.Mail)
{
string subject = loggingType + " логирование с сайта";
var mailerConfig = new MailerConfig {
IsHtmlBody = false,
DisplayName = subject,
SendToAdmins = true
};
var mailer = new Mailer.Mailer();
string mailAddress = loggingType.HasFlag(LoggingType.Error) ? MailAddresses.EXCEPTIONS : MailAddresses.SUPPORT;
isSuccess = mailer.SendMail(mailAddress, mailAddress, subject, formattedMessage, mailerConfig);
if (!isSuccess)
{
LogTo(LoggerName.Errors).ErrorFormat(
"LoggerWrapper.RemoteMessage не удалось отправить сообщение по почте: {0}",
formattedMessage);
}
}
/*if ((loggingSource & LoggingSource.Db) == LoggingSource.Db) {
* isSuccess = _loggerQuery.Create(loggingType, formattedMessage);
*
* if (!isSuccess) {
* LogTo(LoggerName.Errors).ErrorFormat(
* "LoggerWrapper.RemoteMessage не удалось записать сообщение в БД: {0}",
* formattedMessage);
* }
* }*/
}
public static void WriteJournaling(LoggingSource Source, string UserAgent, string ClassMethod, string Message,
LoggingOperationType OperationType, LoggingLevel Level,
Nullable <Guid> IdArchive, Nullable <Guid> IdStorage, Nullable <Guid> IdCorrelation)
{
try
{
if (ConfigurationManager.AppSettings["JournalEnabled"] == null || ConfigurationManager.AppSettings["JournalEnabled"].ToString() == "true")
{
DbProvider.AddJournal(OperationType,
UserAgent,
Guid.NewGuid(),
IdArchive == null ? Guid.Empty : (Guid)IdArchive,
IdStorage == null ? Guid.Empty : (Guid)IdStorage,
IdCorrelation == null ? Guid.Empty : (Guid)IdCorrelation,
Message);
}
}
catch (Exception ex)
{
logger.Error(ex);
}
}
public static void Main(string[] args)
{
try
{
ThreadPool.SetMinThreads(10000, 500);
ServicePointManager.DefaultConnectionLimit = int.MaxValue;
ServicePointManager.UseNagleAlgorithm = false;
ServicePointManager.Expect100Continue = false;
LoggingSource.Initialize(ActorEventSource.Current.Message);
ActorRuntime.RegisterActorAsync <StockTrendPredictionActor>().GetAwaiter().GetResult();
ActorRuntime.RegisterActorAsync <NotificationActor>().GetAwaiter().GetResult();
Thread.Sleep(Timeout.Infinite);
}
catch (Exception e)
{
ActorEventSource.Current.ActorHostInitializationFailed(e.ToString());
throw;
}
}
/// <summary>
/// Logs information to the console and optionally a log file
/// </summary>
/// <param name="source"></param>
/// <param name="type"></param>
/// <param name="msg"></param>
public virtual string Log(LoggingSource source, LogType type, string msg)
{
if (!_config.DebugMode || _paused)
return String.Empty;
string output = String.Empty;
switch (_debugLevel)
{
case IMAPConfig.DebugDetailLevel.All:
{
output = GenerateMessage(type, msg);
break;
}
case IMAPConfig.DebugDetailLevel.ErrorsOnly:
{
if (type == LogType.Error)
output = GenerateMessage(type, msg);
break;
}
case IMAPConfig.DebugDetailLevel.InterIMAPOnly:
{
if (source == LoggingSource.InterIMAP || source == LoggingSource.MessageWorker)
output = GenerateMessage(type, msg);
break;
}
}
if (output != String.Empty)
{
if (_workerID > -1)
output = String.Format("Worker {0} - {1}", _workerID, output);
Console.WriteLine(output);
if (_config.LogFile != String.Empty)
{
string logFile = _config.LogFile;
if (_workerID > -1)
{
string file = Path.GetFileNameWithoutExtension(_config.LogFile);
string path = _config.LogFile.Replace(file, "{0}");
file += String.Format("_{0}", _workerID);
logFile = String.Format(path, file);
}
StreamWriter strWriter = new StreamWriter(logFile, true);
strWriter.WriteLine("{0} - {1}", DateTime.Now, msg);
strWriter.Flush();
strWriter.Close();
}
if (EventLogged != null)
{
EventLogged(output);
}
}
return output;
}
public async Task LoggingSource_WhileRetentionByTimeInHours_ShouldKeepRetentionPolicy(bool compressing)
{
const int fileSize = Constants.Size.Kilobyte;
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
path = Path.Combine(path, Guid.NewGuid().ToString());
Directory.CreateDirectory(path);
var retentionTimeConfiguration = TimeSpan.FromHours(3);
var now = DateTime.Now;
var retentionTime = now - retentionTimeConfiguration;
var toCheckLogFiles = new List <(string fileName, bool shouldExist)>();
const int artificialLogsCount = 9;
for (int i = 0; i < artificialLogsCount; i++)
{
var lastModified = now - TimeSpan.FromHours(i);
var fileName = Path.Combine(path, $"{LoggingSource.LogInfo.DateToLogFormat(lastModified)}.00{artificialLogsCount - i}.log");
toCheckLogFiles.Add((fileName, lastModified > retentionTime));
await using (File.Create(fileName))
{ }
File.SetLastWriteTime(fileName, lastModified);
}
const long retentionSize = long.MaxValue;
var loggingSource = new LoggingSource(
LogMode.Information,
path,
"LoggingSource" + name,
retentionTimeConfiguration,
retentionSize,
compressing)
{
MaxFileSizeInBytes = fileSize
};
//This is just to make sure the MaxFileSizeInBytes is get action for the first file
loggingSource.SetupLogMode(LogMode.Operations, path, retentionTimeConfiguration, retentionSize, compressing);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
for (var j = 0; j < 50; j++)
{
for (var i = 0; i < 5; i++)
{
await logger.OperationsWithWait("Some message");
}
Thread.Sleep(10);
}
string[] afterEndFiles = null;
await WaitForValueAsync(async() =>
{
for (var i = 0; i < 10; i++)
{
await logger.OperationsWithWait("Some message");
}
afterEndFiles = Directory.GetFiles(path);
return(DoesContainFilesThatShouldNotBeFound(afterEndFiles, toCheckLogFiles, compressing));
}, false, 10_000, 1_000);
loggingSource.EndLogging();
AssertNoFileMissing(afterEndFiles);
try
{
Assert.All(toCheckLogFiles, toCheck =>
{
(string fileName, bool shouldExist) = toCheck;
fileName = $"{fileName}{(compressing ? ".gz" : string.Empty)}";
var fileInfo = new FileInfo(fileName);
if (shouldExist)
{
Assert.True(fileInfo.Exists, $"The log file \"{fileInfo.Name}\" should be exist");
}
else
{
Assert.False(fileInfo.Exists, $"The log file \"{fileInfo.Name}\" last modified {fileInfo.LastWriteTime} should not be exist. retentionTime({retentionTime})");
}
});
}
catch (Exception e)
{
throw new InvalidOperationException($"Logs after end - {JustFileNamesAsString(afterEndFiles)}", e);
}
}
/// <summary>
/// Logs information to the console and optionally a log file
/// </summary>
/// <param name="source"></param>
/// <param name="type"></param>
/// <param name="msg"></param>
public virtual string Log(LoggingSource source, LogType type, string msg)
{
if (!_config.DebugMode || _paused)
{
return(String.Empty);
}
string output = String.Empty;
switch (_debugLevel)
{
case IMAPConfig.DebugDetailLevel.All:
{
output = GenerateMessage(type, msg);
break;
}
case IMAPConfig.DebugDetailLevel.ErrorsOnly:
{
if (type == LogType.Error)
{
output = GenerateMessage(type, msg);
}
break;
}
case IMAPConfig.DebugDetailLevel.InterIMAPOnly:
{
if (source == LoggingSource.InterIMAP || source == LoggingSource.MessageWorker)
{
output = GenerateMessage(type, msg);
}
break;
}
}
if (output != String.Empty)
{
if (_workerID > -1)
{
output = String.Format("Worker {0} - {1}", _workerID, output);
}
Console.WriteLine(output);
if (_config.LogFile != String.Empty)
{
string logFile = _config.LogFile;
if (_workerID > -1)
{
string file = Path.GetFileNameWithoutExtension(_config.LogFile);
string path = _config.LogFile.Replace(file, "{0}");
file += String.Format("_{0}", _workerID);
logFile = String.Format(path, file);
}
StreamWriter strWriter = new StreamWriter(logFile, true);
strWriter.WriteLine("{0} - {1}", DateTime.Now, msg);
strWriter.Flush();
strWriter.Close();
}
if (EventLogged != null)
{
EventLogged(output);
}
}
return(output);
}
public async Task LoggingSource_WhileRetentionBySizeOn_ShouldKeepRetentionPolicy(bool compressing)
{
const int fileSize = Constants.Size.Kilobyte;
const int retentionSize = 5 * Constants.Size.Kilobyte;
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
var retentionTime = TimeSpan.MaxValue;
var loggingSource = new LoggingSource(
LogMode.Information,
path,
"LoggingSource" + name,
retentionTime,
retentionSize,
compressing);
loggingSource.MaxFileSizeInBytes = fileSize;
//This is just to make sure the MaxFileSizeInBytes is get action for the first file
loggingSource.SetupLogMode(LogMode.Operations, path, retentionTime, retentionSize, compressing);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
for (var i = 0; i < 100; i++)
{
for (var j = 0; j < 5; j++)
{
await logger.OperationsAsync("Some message");
}
Thread.Sleep(10);
}
var sw = Stopwatch.StartNew();
while (true)
{
await Task.Delay(TimeSpan.FromSeconds(1));
var afterEndFiles = Directory.GetFiles(path);
AssertNoFileMissing(afterEndFiles);
var size = afterEndFiles.Select(f => new FileInfo(f)).Sum(f => f.Length);
const int threshold = 2 * fileSize;
if (Math.Abs(size - retentionSize) <= threshold)
{
break;
}
if (sw.Elapsed < TimeSpan.FromSeconds(10))
{
continue;
}
Assert.True(false,
$"ActualSize({size}), retentionSize({retentionSize}), threshold({threshold})" +
Environment.NewLine +
JustFileNamesAsString(afterEndFiles));
}
loggingSource.EndLogging();
}
public async Task AttachPipeSink_WhenLogModeIsOperations_ShouldWriteToLogFileJustOperations(LogMode logMode)
{
var timeout = TimeSpan.FromSeconds(10);
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
path = Path.Combine(path, Guid.NewGuid().ToString());
Directory.CreateDirectory(path);
var loggingSource = new LoggingSource(
logMode,
path,
"LoggingSource" + name,
TimeSpan.MaxValue,
long.MaxValue,
false);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
var tcs = new TaskCompletionSource <WebSocketReceiveResult>(TaskCreationOptions.RunContinuationsAsynchronously);
await using var stream = new MemoryStream();
//Attach Pipe
loggingSource.AttachPipeSink(stream);
var beforeDetachOperation = Guid.NewGuid().ToString();
var beforeDetachInformation = Guid.NewGuid().ToString();
var logTasks = Task.WhenAll(logger.OperationsAsync(beforeDetachOperation), logger.InfoAsync(beforeDetachInformation));
await Task.WhenAny(logTasks, Task.Delay(timeout));
Assert.True(logTasks.IsCompleted, $"Waited over {timeout.TotalSeconds} seconds for log tasks to finish");
//Detach Pipe
loggingSource.DetachPipeSink();
await stream.FlushAsync();
var afterDetachOperation = Guid.NewGuid().ToString();
var afterDetachInformation = Guid.NewGuid().ToString();
logTasks = Task.WhenAll(logger.OperationsAsync(afterDetachOperation), logger.InfoAsync(afterDetachInformation));
await Task.WhenAny(logTasks, Task.Delay(timeout));
Assert.True(logTasks.IsCompleted || logMode == LogMode.None,
$"Waited over {timeout.TotalSeconds} seconds for log tasks to finish");
tcs.SetResult(new WebSocketReceiveResult(1, WebSocketMessageType.Text, true, WebSocketCloseStatus.NormalClosure, ""));
loggingSource.EndLogging();
var logsFromPipe = Encodings.Utf8.GetString(stream.ToArray());
Assert.Contains(beforeDetachInformation, logsFromPipe);
Assert.Contains(beforeDetachOperation, logsFromPipe);
Assert.DoesNotContain(afterDetachInformation, logsFromPipe);
Assert.DoesNotContain(afterDetachOperation, logsFromPipe);
string logsFileContentAfter = await ReadLogsFileContent(path);
AssertContainsLog(LogMode.Information, logMode)(beforeDetachInformation, logsFileContentAfter);
AssertContainsLog(LogMode.Operations, logMode)(beforeDetachOperation, logsFileContentAfter);
AssertContainsLog(LogMode.Information, logMode)(afterDetachInformation, logsFileContentAfter);
AssertContainsLog(LogMode.Operations, logMode)(afterDetachOperation, logsFileContentAfter);
}
public static void Log(LoggingSource source, string text, params string[] replacement)
{
string replacementExpanded = string.Format(text, replacement);
Log(source, replacementExpanded);
}
public async Task LoggingSource_WhileStopAndStartAgain_ShouldNotOverrideOld(bool compressing)
{
const int taskTimeout = 10000;
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
var retentionTime = TimeSpan.MaxValue;
var retentionSize = long.MaxValue;
var firstLoggingSource = new LoggingSource(
LogMode.Information,
path,
"FirstLoggingSource" + name,
retentionTime,
retentionSize,
compressing);
firstLoggingSource.MaxFileSizeInBytes = 1024;
//This is just to make sure the MaxFileSizeInBytes is get action for the first file
firstLoggingSource.SetupLogMode(LogMode.Operations, path, retentionTime, retentionSize, compressing);
try
{
var logger = new Logger(firstLoggingSource, "Source" + name, "Logger" + name);
for (var i = 0; i < 100; i++)
{
var task = logger.OperationsAsync("Some message");
await Task.WhenAny(task, Task.Delay(taskTimeout));
if (task.IsCompleted == false)
{
throw new TimeoutException($"The log task took more then one second");
}
}
}
finally
{
firstLoggingSource.EndLogging();
}
var beforeRestartFiles = Directory.GetFiles(path);
var restartDateTime = DateTime.Now;
Exception anotherThreadException = null;
//To start new LoggingSource the object need to be construct on another thread
var anotherThread = new Thread(() =>
{
var secondLoggingSource = new LoggingSource(
LogMode.Information,
path,
"SecondLoggingSource" + name,
retentionTime,
retentionSize);
try
{
secondLoggingSource.MaxFileSizeInBytes = 1024;
var secondLogger = new Logger(secondLoggingSource, "Source" + name, "Logger" + name);
for (var i = 0; i < 100; i++)
{
var task = secondLogger.OperationsAsync("Some message");
Task.WhenAny(task, Task.Delay(taskTimeout)).GetAwaiter().GetResult();
if (task.IsCompleted == false)
{
throw new TimeoutException($"The log task took more then one second");
}
}
}
catch (Exception e)
{
anotherThreadException = e;
}
finally
{
secondLoggingSource.EndLogging();
}
});
anotherThread.Start();
anotherThread.Join();
if (anotherThreadException != null)
{
throw anotherThreadException;
}
foreach (var file in beforeRestartFiles.OrderBy(f => f).SkipLast(1)) //The last is skipped because it is still written
{
var lastWriteTime = File.GetLastWriteTime(file);
Assert.True(
restartDateTime > lastWriteTime,
$"{file} was changed (time:" +
$"{lastWriteTime.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture)}) after the restart (time:" +
$"{restartDateTime.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture)})" +
Environment.NewLine +
JustFileNamesAsString(beforeRestartFiles));
}
}
public async Task LoggingSource_WhileRetentionByTimeOn_ShouldKeepRetentionPolicy(bool compressing)
{
const int fileSize = Constants.Size.Kilobyte;
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
path = Path.Combine(path, Guid.NewGuid().ToString());
Directory.CreateDirectory(path);
var retentionTime = TimeSpan.FromDays(3);
var retentionDate = DateTime.Now.Date - retentionTime;
var toCheckLogFiles = new List <(string, bool)>();
for (var date = retentionDate - TimeSpan.FromDays(1); date <= retentionDate + TimeSpan.FromDays(1); date += TimeSpan.FromDays(1))
{
var fileName = Path.Combine(path, LoggingSource.LogInfo.GetFileName(date) + ".001.log");
toCheckLogFiles.Add((fileName, date >= retentionDate));
var file = File.Create(fileName);
file.Dispose();
}
var retentionSize = long.MaxValue;
var loggingSource = new LoggingSource(
LogMode.Information,
path,
"LoggingSource" + name,
retentionTime,
retentionSize,
compressing);
loggingSource.MaxFileSizeInBytes = fileSize;
//This is just to make sure the MaxFileSizeInBytes is get action for the first file
loggingSource.SetupLogMode(LogMode.Operations, path, retentionTime, retentionSize, compressing);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
for (var j = 0; j < 50; j++)
{
for (var i = 0; i < 5; i++)
{
await logger.OperationsAsync("Some message");
}
Thread.Sleep(10);
}
loggingSource.EndLogging();
var afterEndFiles = Directory.GetFiles(path);
AssertNoFileMissing(afterEndFiles);
try
{
foreach (var(fileName, shouldExist) in toCheckLogFiles)
{
var compressedFileName = fileName + ".gz";
if (shouldExist)
{
Assert.True(afterEndFiles.Contains(fileName) || afterEndFiles.Contains(compressedFileName),
$"The log file \"{Path.GetFileNameWithoutExtension(fileName)}\" and all log files from and after {retentionDate} " +
"should be deleted due to time retention");
}
else
{
Assert.False(afterEndFiles.Contains(fileName),
$"The file \"{fileName}\" and all log files from before {retentionDate} should be deleted due to time retention");
Assert.False(afterEndFiles.Contains(compressedFileName),
$"The file \"{compressedFileName}\" and all log files from before {retentionDate} should be deleted due to time retention");
}
}
}
catch (Exception e)
{
throw new InvalidOperationException($"Logs after end - {JustFileNamesAsString(afterEndFiles)}", e);
}
}
public async Task Register_WhenLogModeIsOperations_ShouldWriteToLogFileJustAsLogMode(LogMode logMode)
{
var timeout = TimeSpan.FromSeconds(10);
var name = GetTestName();
var path = NewDataPath(forceCreateDir: true);
path = Path.Combine(path, Guid.NewGuid().ToString());
Directory.CreateDirectory(path);
var loggingSource = new LoggingSource(
logMode,
path,
"LoggingSource" + name,
TimeSpan.MaxValue,
long.MaxValue,
false);
var logger = new Logger(loggingSource, "Source" + name, "Logger" + name);
var tcs = new TaskCompletionSource <WebSocketReceiveResult>(TaskCreationOptions.RunContinuationsAsynchronously);
var socket = new DummyWebSocket();
socket.ReceiveAsyncFunc = () => tcs.Task;
var context = new LoggingSource.WebSocketContext();
//Register
var _ = loggingSource.Register(socket, context, CancellationToken.None);
var beforeCloseOperation = Guid.NewGuid().ToString();
var beforeCloseInformation = Guid.NewGuid().ToString();
var logTasks = Task.WhenAll(logger.OperationsAsync(beforeCloseOperation), logger.InfoAsync(beforeCloseInformation));
await Task.WhenAny(logTasks, Task.Delay(timeout));
Assert.True(logTasks.IsCompleted, $"Waited over {timeout.TotalSeconds} seconds for log tasks to finish");
const int socketTimeout = 5000;
var socketContainsLogs = WaitForValue(() => socket.LogsReceived.Contains(beforeCloseInformation) && socket.LogsReceived.Contains(beforeCloseOperation),
true, socketTimeout, 100);
Assert.True(socketContainsLogs, $"Waited over {socketTimeout} seconds for log to be written to socket");
//Close socket
socket.Close();
tcs.SetResult(new WebSocketReceiveResult(1, WebSocketMessageType.Text, true, WebSocketCloseStatus.NormalClosure, string.Empty));
var afterCloseOperation = Guid.NewGuid().ToString();
var afterCloseInformation = Guid.NewGuid().ToString();
logTasks = Task.WhenAll(logger.OperationsAsync(afterCloseOperation), logger.InfoAsync(afterCloseInformation));
await Task.WhenAny(logTasks, Task.Delay(timeout));
Assert.True(logTasks.IsCompleted || logMode == LogMode.None,
$"Waited over {timeout.TotalSeconds} seconds for log tasks to finish");
loggingSource.EndLogging();
string logsFileContentAfter = await ReadLogsFileContent(path);
AssertContainsLog(LogMode.Information, logMode)(beforeCloseInformation, logsFileContentAfter);
AssertContainsLog(LogMode.Operations, logMode)(beforeCloseOperation, logsFileContentAfter);
AssertContainsLog(LogMode.Information, logMode)(afterCloseInformation, logsFileContentAfter);
AssertContainsLog(LogMode.Operations, logMode)(afterCloseOperation, logsFileContentAfter);
}
