public void StreamLogger_Log()
{
#region Arrange
var msg = new LogRecord();
var writer = new MemoryStream();
var serializer = new StringLogSerializer();
var logger = new StreamLogger(writer)
{
Serializer = serializer
};
var expectedMsg = serializer.Serialize(msg) + Environment.NewLine;
var beforeCanWrite = logger.Writer.CanWrite;
#endregion Arrange
#region Act
logger.Log(msg);
#endregion Act
#region Assert
Assert.AreEqual(expectedMsg, logger.Encoding.GetString(writer.ToArray()));
Assert.AreEqual(beforeCanWrite, logger.Writer.CanWrite);
#endregion Assert
}
public IEnumerable <string> ExportToFiles(Summary summary, ILogger consoleLogger)
{
string fileName = GetFileName(summary);
string filePath = GetArtifactFullName(summary);
if (File.Exists(filePath))
{
try
{
File.Delete(filePath);
}
catch (IOException)
{
string uniqueString = DateTime.Now.ToString("yyyyMMdd-HHmmss");
string alternativeFilePath = $"{Path.Combine(summary.ResultsDirectoryPath, fileName)}-{FileCaption}{FileNameSuffix}-{uniqueString}.{FileExtension}";
consoleLogger.WriteLineError($"Could not overwrite file {filePath}. Exporting to {alternativeFilePath}");
filePath = alternativeFilePath;
}
}
using (var stream = new StreamWriter(filePath, append: false))
{
using (var streamLogger = new StreamLogger(stream))
{
ExportToLog(summary, streamLogger);
}
}
return(new[] { filePath });
}
public void SetUp()
{
stream = new MemoryStream();
logger = new StreamLogger(Name, stream);
logger.Level = LoggerLevel.Trace;
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
using (var logger = new StreamLogger(new StreamWriter(DateTime.Now.Date.ToString("dd/MM/yyyy") + ".log")
{
AutoFlush = true
}))
{
Application.Run(new MainForm(
logger,
new CompleteTestResultRepository(
logger,
Options.Create <DbSettings>(
new DbSettings
{
ConnectionString = Properties.Settings.Default.ConnectionString,
Database = Properties.Settings.Default.Database
}
)
)
));
}
}
public void StreamLogger_DestructorDispose()
{
#region Arrange
var writer = new MemoryStream();
var logger = new StreamLogger(writer);
var beforeCanWrite = logger.Writer.CanWrite;
#endregion Arrange
#region Act
logger.Log(LogRecord.Empty);
logger = null;
GC.Collect();
//Need wait for destructor call
Task.Delay(50).Wait();
#endregion Act
#region Assert
Assert.AreNotEqual(beforeCanWrite, writer.CanWrite);
#endregion Assert
}
private ILogger CreateLogger(Stream logStream_)
{
var logger = new StreamLogger(LoggerName, logStream_);
logger.TimeProvider = new FixedTimeProvider(LogDate);
return(logger);
}
public void StreamLogger_Dispose()
{
#region Arrange
var writer = new MemoryStream();
var logger = new StreamLogger(writer);
var beforeCanWrite = logger.Writer.CanWrite;
#endregion Arrange
#region Act
using (logger)
{
logger.Log(LogRecord.Empty);
}
#endregion Act
#region Assert
Assert.IsFalse(logger.Writer.CanWrite);
Assert.AreNotEqual(beforeCanWrite, writer.CanWrite);
#endregion Assert
}
public void BroadcasterTest()
{
const string message = "Testestest";
var memoryStream1 = new MemoryStream();
var reader1 = new StreamReader(memoryStream1);
var writer1 = new StreamWriter(memoryStream1);
var logger1 = new StreamLogger(writer1);
var memoryStream2 = new MemoryStream();
var reader2 = new StreamReader(memoryStream2);
var writer2 = new StreamWriter(memoryStream2);
var logger2 = new StreamLogger(writer2);
var logger = new LogBroadcaster(new List <Logger>()
{
logger1, logger2
});
logger.Log(message);
logger.Close();
memoryStream1.Seek(0, SeekOrigin.Begin);
Assert.Equal(message, reader1.ReadLine());
Assert.Null(reader1.ReadLine());
memoryStream2.Seek(0, SeekOrigin.Begin);
Assert.Equal(message, reader2.ReadLine());
Assert.Null(reader2.ReadLine());
}
public virtual void TestInitialize()
{
Logger = new StreamLogger(new StreamWriter(DateTime.Now.Date.ToString("dd/MM/yyyy") + ".log")
{
AutoFlush = true
});
}
public void SetUp()
{
stream = new MemoryStream();
logger = new StreamLogger(Name, stream);
logger.Level = LoggerLevel.Debug;
}
private void StartLogging()
{
_logger = new HostLogger(LogLevel);
// We need to not write log messages to Stdio
// if it's being used as a protocol transport
if (!Stdio)
{
var hostLogger = new PSHostLogger(Host.UI);
_loggerUnsubscribers.Add(_logger.Subscribe(hostLogger));
}
string logDirPath = GetLogDirPath();
string logPath = Path.Combine(logDirPath, "StartEditorServices.log");
// Temp debugging sessions may try to reuse this same path,
// so we ensure they have a unique path
if (File.Exists(logPath))
{
int randomInt = new Random().Next();
logPath = Path.Combine(logDirPath, $"StartEditorServices-temp{randomInt.ToString("X", CultureInfo.InvariantCulture.NumberFormat)}.log");
}
var fileLogger = StreamLogger.CreateWithNewFile(logPath);
_disposableResources.Add(fileLogger);
IDisposable fileLoggerUnsubscriber = _logger.Subscribe(fileLogger);
fileLogger.AddUnsubscriber(fileLoggerUnsubscriber);
_loggerUnsubscribers.Add(fileLoggerUnsubscriber);
_logger.Log(PsesLogLevel.Diagnostic, "Logging started");
}
public void SetUp()
{
stream = new MemoryStream();
sut = new StreamLogger(stream)
{
SystemClock = () => new DateTime(2000, 1, 2, 3, 4, 5)
};
}
public void SetUp()
#endif
{
stream = new MemoryStream();
logger = new StreamLogger(Name, stream);
logger.Level = LoggerLevel.Debug;
}
public MarketModel Download(MarketModel market, SettingModel settings, ILogHandler logger)
{
if (market == null)
{
throw new ArgumentNullException(nameof(market));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
Log.LogHandler = logger;
Config.Set("data-directory", settings.DataFolder);
Config.Set("data-folder", settings.DataFolder);
Config.Set("cache-location", settings.DataFolder);
using (var writer = new StreamLogger(logger))
{
Console.SetOut(writer);
IProvider provider = CreateProvider(settings, market.Provider);
if (provider == null)
{
market.Active = false;
}
else
{
try
{
// Check default values
if (string.IsNullOrEmpty(market.Market))
{
market.Market = market.Provider;
}
if (market.Security.Equals(SecurityType.Base))
{
market.Security = SecurityType.Equity;
}
provider.Download(market, settings);
}
catch (Exception ex)
{
Log.Error(string.Format(
CultureInfo.InvariantCulture,
"{0}: {1}",
ex.GetType(),
ex.Message));
market.Active = false;
}
}
}
Log.LogHandler.Dispose();
return(market);
}
public void Error_Log_Call_Shoould_Write_File_Expected_Message__And_Path()
{
string message = LoggerProvider.CreateLogMessage(MessageLength.Normal);
string expectedMessage = $"{_dateTimeProviderMock.UtcNow} [ERROR] {message}";
using (var stream = _streamFactoryMock.Create())
{
var streamLogger = new StreamLogger(stream, _dateTimeProviderMock, _streamWriterMock);
streamLogger.Log(LogLevel.Error, message);
_streamWriterMock.Received().Writeline(Arg.Any <Stream>(), Arg.Is(expectedMessage));
}
}
public async Task Async_Info_Log_Call_Shoould_Write_File_Expected_Message__And_Path()
{
string message = LoggerProvider.CreateLogMessage(MessageLength.Normal);
string expectedMessage = $"{_dateTimeProviderMock.UtcNow} [INFO] {message}";
using (var stream = _streamFactoryMock.Create())
{
var streamLogger = new StreamLogger(stream, _dateTimeProviderMock, _streamWriterMock);
await streamLogger.LogAsync(LogLevel.Info, message);
await _streamWriterMock.Received().WriteLineAsync(Arg.Any <Stream>(), Arg.Is(expectedMessage));
}
}
private async void CreateLoggerAsync()
{
StorageFolder logFolder = ApplicationData.Current.TemporaryFolder;
Stream fileStream = await logFolder.OpenStreamForWriteAsync("AppLog.txt", CreationCollisionOption.ReplaceExisting);
#if DEBUG
LogLevel minimumLogLevel = LogLevel.Debug;
#else
LogLevel minimumLogLevel = LogLevel.Warning;
#endif
var streamLogger = new StreamLogger(fileStream, minimumLogLevel);
Logger = streamLogger;
}
public void TestLog__MessageNull()
{
using (MemoryStream stream = new MemoryStream(new byte[0], true))
{
StreamLogger streamLogger = new StreamLogger(stream);
ArgumentNullException ex = Assert.Throws <ArgumentNullException>(delegate
{
streamLogger.Log(null);
});
Assert.Equal("message", ex.ParamName);
}
}
public MarketModel Run(MarketModel market, SettingService settings, ILogHandler logger)
{
if (market == null)
{
throw new ArgumentNullException(nameof(market));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
Log.LogHandler = logger;
PrepareDataFolder(settings.DataFolder);
using (var writer = new StreamLogger(logger))
{
Console.SetOut(writer);
IList <string> symbols = market.Symbols.Select(m => m.Name).ToList();
if (!symbols.Any())
{
Log.Trace($"No symbols selected");
market.Active = false;
return(market);
}
IProvider provider = CreateProvider(market.Provider);
if (provider == null)
{
market.Active = false;
}
try
{
provider.Download(market, settings, symbols);
}
catch (Exception ex)
{
Log.Error(string.Format(
CultureInfo.InvariantCulture,
"{0}: {1}",
ex.GetType(),
ex.Message));
market.Active = false;
}
}
Log.LogHandler.Dispose();
return(market);
}
public void TestLog__AlreadyDisposed()
{
using (MemoryStream stream = new MemoryStream(new byte[0], true))
{
StreamLogger streamLogger = new StreamLogger(stream);
streamLogger.Dispose();
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(delegate
{
streamLogger.Log(Substitute.For <ILogMessage>());
});
Assert.Contains("Object has already been disposed", ex.Message);
}
}
public void StreamLoggerTest()
{
const string message = "Test";
var memoryStream = new MemoryStream();
var reader = new StreamReader(memoryStream);
var writer = new StreamWriter(memoryStream);
var logger = new StreamLogger(writer);
logger.Log(message);
logger.Close();
memoryStream.Seek(0, SeekOrigin.Begin);
Assert.Equal(message, reader.ReadLine());
Assert.Null(reader.ReadLine());
}
private static void Main(String[] args)
{
using (var logger = new StreamLogger(new StreamWriter(DateTime.Now.Date.ToString("dd/MM/yyyy") + ".log")
{
AutoFlush = true
}))
{
var parser = new FluentCommandLineParser();
String exe = null;
String path = null;
parser.Setup <String>("p", longOption: "path")
.Callback(e => path = e);
parser.Setup <String>("e", longOption: "exe")
.Callback(e => exe = e);
parser.Parse(args);
logger.Info(exe);
ITester tester = new Tester(
logger,
new ZipCollectorTests(
logger,
path,
new String[] { "228", "123" }
),
new CheckAllTestsLauncher
(
new OneTestRunner(
logger,
new FullStreamComparer(),
exe
)
)
);
var result = tester.Run();
List <TestResult> l = new List <TestResult>(result);
IPostman postman = new GmailPostman(logger, "*****@*****.**", "123456vkr^^", "TesterSfedu");
postman.Send("*****@*****.**", "Test", l);
}
}
/// <summary>
/// Dependency injection container for all the system's entities
/// </summary>
/// <param name="config">Configuration provider, defaults to DefaultConfig.cs</param>
/// <param name="cache">Cache wrapper, defaults to SimpleInMemoryCache</param>
/// <param name="dbWrapper">DB Wrapper, especially useful for tests. Defauls to RelationalDatabaseWrapper</param>
/// <param name="customersFacade">A facade to customers data. Defaults to CustomersDbManager</param>
/// <param name="taxesFacade">A facade to taxes data. Defaults to TaxesDbManager</param>
/// <param name="ordersFacade">A facade to orders data. Defaults to OrdersDbManager</param>
public DefaultContainer(
IConfig config = null,
IKeyValueCache cache = null,
IDatabaseWrapper dbWrapper = null,
ICustomerFacade customersFacade = null,
ITaxesFacade taxesFacade = null,
IOrdersFacade ordersFacade = null)
{
Config = config ?? new DefaultConfig();
Logger = new StreamLogger(Console.OpenStandardOutput());
Cache = cache ?? new SimpleInMemoryCache();
DbWrapper = dbWrapper ?? new RelationalDatabaseWrapper(Config.DATABASE_URL, Cache, Config.ROOT_QUERIES_DIR, Logger);
CustomersFacade = customersFacade ?? new CustomersDbManager(DbWrapper);
TaxesFacade = taxesFacade ?? new TaxesDbManager(DbWrapper);
OrdersFacade = ordersFacade ?? new OrdersDbManager(DbWrapper);
}
private string SaveDisassemblyResult(Summary summary, DisassemblyResult disassemblyResult)
{
string filePath = $"{Path.Combine(summary.ResultsDirectoryPath, Guid.NewGuid().ToString())}-diff.temp";
if (File.Exists(filePath))
{
File.Delete(filePath);
}
using (var stream = new StreamWriter(filePath, append: false))
{
using (var streamLogger = new StreamLogger(stream))
{
GithubMarkdownDisassemblyExporter.Export(streamLogger, disassemblyResult, config, quotingCode: false);
}
}
return(filePath);
}
public void StreamLoggerTest_TestWriteSuccessful()
{
string result;
using (var ms = new MemoryStream())
{
using (StreamLogger logger = new StreamLogger(ms))
{
logger.Log(LogLevel.Info, "Test message");
ms.Flush();
ms.Position = 0;
using (var sr = new StreamReader(ms))
{
result = sr.ReadToEnd();
}
}
}
Assert.Contains("Test message", result);
}
public void TestFailoverMechanism()
{
var stream = new MemoryStream();
var logger = new StreamLogger(stream);
logger.SystemClock = () => new DateTime(2000, 1, 1, 14, 15, 16);
var guard = new FailGuard(logger);
var success = false;
guard.Attempt(
() => { throw new Exception("Call failed."); },
() => { success = true; });
Assert.IsTrue(success);
var lines = stream.GetLines();
Assert.AreEqual("[2000.01.01 14:15:16 E] Call failed.", lines[0]);
Assert.AreEqual("[2000.01.01 14:15:16 D] Success.", lines[1]);
}
public IEnumerator Run()
{
PostPatchLoader.Instance.databaseConfigs = null;
if (!Directory.Exists(logsDirPath))
{
Directory.CreateDirectory(logsDirPath);
}
kspLogger.Info("Patching started on a new thread, all output will be directed to " + logPath);
MessageQueue <ILogMessage> mmLogQueue = new MessageQueue <ILogMessage>();
QueueLogRunner logRunner = new QueueLogRunner(mmLogQueue);
ITaskStatus loggingThreadStatus = BackgroundTask.Start(delegate
{
using StreamLogger streamLogger = new StreamLogger(new FileStream(logPath, FileMode.Create));
streamLogger.Info("Log started at " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
logRunner.Run(streamLogger);
streamLogger.Info("Done!");
});
static void Main(string[] args)
{
var version = System.Reflection.Assembly.GetEntryAssembly().GetName().Version;
Console.WriteLine();
Console.WriteLine($"SteadyBuild Poller {version.Major}.{version.Minor}.{version.Revision}");
Console.WriteLine();
var connectionString = args[0];
var logger = new StreamLogger(Console.Out, Abstractions.MessageSeverity.Debug);
using (var connection = new System.Data.SqlClient.SqlConnection(connectionString))
{
var repository = new SteadyBuild.Manager.DbProjectRepository(connection);
var poller = new ProjectPoller(repository, repository, logger);
var cancelTokenSource = new System.Threading.CancellationTokenSource();
// Poll for changes and queue the build.
poller.StartAsync(cancelTokenSource.Token).Wait();
}
}
public void TestLog__Assert()
{
byte[] bytes = new byte[50];
using (MemoryStream stream = new MemoryStream(bytes, true))
{
using (StreamLogger streamLogger = new StreamLogger(stream))
{
streamLogger.Log(LogType.Assert, "a message");
}
}
using (MemoryStream stream = new MemoryStream(bytes, false))
{
using (StreamReader reader = new StreamReader(stream))
{
string result = reader.ReadToEnd();
Assert.Contains("[AST ", result);
Assert.Contains("] a message", result);
}
}
}
private static string Export(Summary summary, BenchmarkCase benchmarkCase, DisassemblyResult disassemblyResult, PmcStats pmcStats)
{
string filePath = $"{Path.Combine(summary.ResultsDirectoryPath, benchmarkCase.Descriptor.WorkloadMethod.Name)}-{benchmarkCase.Job.Environment.Jit}-{benchmarkCase.Job.Environment.Platform}-instructionPointer.html";
if (File.Exists(filePath))
{
File.Delete(filePath);
}
var totals = SumHardwareCountersStatsOfBenchmarkedCode(disassemblyResult, pmcStats);
var perMethod = SumHardwareCountersPerMethod(disassemblyResult, pmcStats);
using (var stream = new StreamWriter(filePath, append: false))
{
using (var streamLogger = new StreamLogger(stream))
{
Export(streamLogger, benchmarkCase, totals, perMethod, pmcStats.Counters.Keys.ToArray());
}
}
return(filePath);
}
private string Export(Summary summary, BenchmarkCase benchmarkCase, DisassemblyResult disassemblyResult, PmcStats pmcStats)
{
string filePath = Path.Combine(summary.ResultsDirectoryPath,
$"{FolderNameHelper.ToFolderName(benchmarkCase.Descriptor.Type)}." +
$"{benchmarkCase.Descriptor.WorkloadMethod.Name}." +
$"{GetShortRuntimeInfo(summary[benchmarkCase].GetRuntimeInfo())}.counters.html");
filePath.DeleteFileIfExists();
var totals = SumHardwareCountersStatsOfBenchmarkedCode(disassemblyResult, pmcStats);
var perMethod = SumHardwareCountersPerMethod(disassemblyResult, pmcStats);
using (var stream = new StreamWriter(filePath, append: false))
{
using (var streamLogger = new StreamLogger(stream))
{
Export(streamLogger, benchmarkCase, totals, perMethod, pmcStats.Counters.Keys.ToArray());
}
}
return(filePath);
}
protected override void OnStart(string[] args)
{
string logDir = ConfigManager.AppSettings["LogDirectory"].ToString();
string logFileName = logDir + "ServiceAgentLog_" + DateTime.Now.ToString("MMMMddyyyyhhmmss") + ".xml";
FileStream fs = new FileStream(logFileName, FileMode.OpenOrCreate, FileAccess.ReadWrite);
StreamLogger logStream = new StreamLogger(fs, true);
logStream.IsIDGenerationEnabled = true;
logStream.IsLineBreakingEnabled = true;
logStream.IsPreambleEnabled = true;
logStream.IsExceptionAutoFlushEnabled = true;
logStream.IsContextEnabled = true;
logStream.Open();
try {
try {
logStream.Log("Service started successfully...");
//retry the action if it fails to start the thread every 30 seconds.
//suspected to throw exception during starting the service if the internet is not yet ready.
RetryAction(() => Start(), 1000 * 30);
} catch (Exception tex) {
logStream.Log("SSISPackageExecution using Windows Azure Message Queue");
logStream.Log(String.Format("Error in starting service: {0}", tex.Message + Environment.NewLine + tex.StackTrace));
if (tex.InnerException != null) {
logStream.Log("Inner Exception: " + tex.InnerException.Message.ToString());
}
}
} catch (Exception ex) {
logStream.Log(ex);
} finally {
logStream.Close();
}
}
