public void EventIdWrittenToEventLogUsesDefaultIfSpecified()
{
// Arrange
var loggerName = "Test";
var expectedMessage = "Category: " + loggerName + Environment.NewLine +
"EventId: 1" + Environment.NewLine + Environment.NewLine +
"Message" + Environment.NewLine;
var testEventLog = new TestEventLog(expectedMessage.Length)
{
DefaultEventId = 1034
};
var logger = new EventLogLogger(loggerName, new EventLogSettings()
{
EventLog = testEventLog
}, new LoggerExternalScopeProvider());
// Act
logger.LogInformation(new EventId(1, "FooEvent"), "Message");
// Assert
Assert.Single(testEventLog.Messages);
Assert.Equal(expectedMessage, testEventLog.Messages[0]);
Assert.Equal(1034, testEventLog.Entries[0].EventId);
}
private EventLogLogger ReadEventLogLoggerSection(XmlNode xmlNode)
{
String source, logName;
Boolean enabled = true;
//Read source attribute
XmlAttribute attribute = xmlNode.Attributes["source"];
if (attribute == null)
{
throw new ArgumentNullException("source", "eventLogLogger is not configuried!");
}
source = attribute.Value;
//Read logName attribute
attribute = xmlNode.Attributes["logName"];
if (attribute == null)
{
throw new ArgumentNullException("logName", "eventLogLogger is not configuried!");
}
logName = attribute.Value;
//Read optional enabled attribute
attribute = xmlNode.Attributes["enabled"];
if (attribute != null)
{
enabled = Boolean.Parse(attribute.Value);
}
EventLogLogger logger = new EventLogLogger(source, logName);
logger.Enabled = enabled;
return(logger);
}
static void Main(string[] args)
{
ILoggerManager loggerManager = new LoggerManager();
Dictionary <string, object> settings = new Dictionary <string, object>();
settings.Add("Log4Net.ConversionPattern", "%date [%thread] %-5level %logger - %message%newline");
settings.Add("Log4Net.MaximumFileSize", "1MB");
settings.Add("Log4Net.MaxSizeRollBackups", 5);
settings.Add("Log4Net.File", @"d:\Log4NetLogger.txt");
ILogger log4NetLogger = new Log4NetLogger("Log4NetLogger");
log4NetLogger.Configure(settings);
loggerManager.AddLogger("Log4NetLogger", log4NetLogger);
ILogger eventLogLogger = new EventLogLogger("TestApp", "Application", 400, null);
loggerManager.AddLogger("EventLogLogger", eventLogLogger);
SystemLogger systemLogger = new SystemLogger(loggerManager);
systemLogger.LogInfo("This is my first info log.");
systemLogger.LogDebug("This is my first debug log.");
systemLogger.LogWarning("This is my first warning log.");
systemLogger.LogError(ErrorSeverity.Low, "This is my first low error log.", new Exception("This is my first low error log."));
systemLogger.LogError(ErrorSeverity.Medium, "This is my first medium error log.", new Exception("This is my first medium error log."));
systemLogger.LogError(ErrorSeverity.High, "This is my first high error log.", new Exception("This is my first high error log."));
systemLogger.LogError(ErrorSeverity.Extreme, "This is my first extreme error log.", new Exception("This is my first extreme error log."));
systemLogger.LogMethodStart("static void Main(string[] args)", new string[] { "args" }, new object[] { args });
systemLogger.LogMethodEnd("static void Main(string[] args)", true);
systemLogger.LogMethodEnd("static void Main(string[] args)", false);
}
public Service1()
{
InitializeComponent();
this.CanStop = true;
this.CanPauseAndContinue = false;
this.AutoLog = true;
var configuration = new Configuration();
var credentials = new VssBasicCredential(string.Empty, configuration.TfsToken);
var connection = new VssConnection(configuration.TfsUri, credentials);
var tfsClient = connection.GetClient <WorkItemTrackingHttpClient>();
var receiver = new TfsNotUpdatedReceiver(tfsClient, configuration);
var receiver2 = new TfsReceiver1(tfsClient, configuration);
var slackClient = new SlackClient(configuration.SlackUri.ToString());
var sender = new SlackSender(slackClient, configuration);
var logger = new EventLogLogger(configuration);
var aggregatedReceiver = new AggregatedReceiver(receiver, receiver2);
var aggregatedSender = new AggregatedSender(sender);
this.notifier = new Notifier(aggregatedReceiver, aggregatedSender, logger, configuration);
}
public void Message_WritesFullMessageWithScopes()
{
// Arrange
var loggerName = "Test";
var expectedMessage = "Category: " + loggerName + Environment.NewLine +
"EventId: 0" + Environment.NewLine +
"Outer Scope" + Environment.NewLine +
"Inner Scope" + Environment.NewLine + Environment.NewLine +
"Message" + Environment.NewLine;
var testEventLog = new TestEventLog(expectedMessage.Length);
var logger = new EventLogLogger(loggerName, new EventLogSettings()
{
EventLog = testEventLog
}, new LoggerExternalScopeProvider());
// Act
using (logger.BeginScope("Outer Scope"))
using (logger.BeginScope("Inner Scope"))
{
logger.LogInformation("Message");
}
// Assert
Assert.Single(testEventLog.Messages);
Assert.Equal(expectedMessage, testEventLog.Messages[0]);
}
public void Message_WritesFullMessageWithScopes()
{
// Arrange
var loggerName = "Test";
var maxMessageSize = 50 + loggerName.Length + Environment.NewLine.Length;
var expectedMessage = loggerName + Environment.NewLine +
"Message" + Environment.NewLine +
"Outer Scope" + Environment.NewLine +
"Inner Scope";
var testEventLog = new TestEventLog(maxMessageSize);
var logger = new EventLogLogger(loggerName, new EventLogSettings()
{
EventLog = testEventLog
});
// Act
using (logger.BeginScope("Outer Scope"))
using (logger.BeginScope("Inner Scope"))
{
logger.LogInformation("Message");
}
// Assert
Assert.Single(testEventLog.Messages);
Assert.Equal(expectedMessage, testEventLog.Messages[0]);
}
public void EventLogLoggerPropertyTest()
{
SharePointLogger logger = new SharePointLogger();
try
{
IEventLogLogger iELogger = logger.EventLogLogger;
EventLogLogger elogger = new EventLogLogger();
if (!iELogger.GetType().IsInterface)
{
if (iELogger.GetType().ToString() == elogger.GetType().ToString())
{
Assert.IsTrue(true);
}
else
{
Assert.Fail("There is a type mismatch");
}
}
else
{
Assert.Fail("Interface was returned");
}
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
public void LogEvents()
{
EventLogLogger logger = new EventLogLogger("Application");
logger.CreateLogs("Support\\TestData\\TestOutput");
Assert.IsTrue(File.Exists("Support\\TestData\\TestOutput\\Application_events.xml"));
}
private static void InitializeWcfHost()
{
var instance = new OnyxLoader();
EventLogLogger.Write(EventLogEntryType.Information, "Initializing wcf host of type {0} (instance {1})", typeof(IOnyxLoaderContract), instance);
m_host = new OnyxServiceHost <IOnyxLoaderContract>(instance);
m_host.Start();
}
public void EventLogLoggerTest()
{
DependencyContainer.Register <EventLogLogger, EventLogLogger>();
EventLogLogger eventLogLogger = DependencyContainer.Resolve <EventLogLogger>();
eventLogLogger.Log("Hello Earthlings!");
var eventLog = new EventLog
}
public void EventLogSourceExistsTest_SourceDoesNotExist_Fail()
{
string appName = "some definitely incorrect event source",
logName = "New test log";
EventLogLogger logger = new EventLogLogger(appName, logName);
Assert.IsFalse(logger.EventLogSourceExists());
}
public void EventLogSourceExistsTest_SourceExists_Success()
{
string appName = "EventLogLoggerTest",
logName = "New test log";
EventLogLogger logger = new EventLogLogger(appName, logName);
Assert.IsTrue(logger.EventLogSourceExists());
}
private static void TestEventLog()
{
EventLogLogger eventLog = new EventLogLogger(new LogMessageFactory());
eventLog.Warn("test ojej");
eventLog.Fatal("test ojej 2");
eventLog.Info("test ojej 3");
eventLog.Dispose();
}
/// <summary>
/// Enables the event log.
/// </summary>
public static void Execute(IOutputService outputService)
{
// SRM runs as an admin, so using the event logger will create the event log.
// The event log will be created successfully as we have elevated priviledges.
var logger = new EventLogLogger();
logger.LogMessage("Enabling the Event Log for SharpShell.");
// Let the user know we're in business.
outputService.WriteSuccess("Event log enabled.");
}
public void CallingBeginScopeOnLogger_ReturnsNonNullableInstance()
{
// Arrange
var logger = new EventLogLogger("Test");
// Act
var disposable = logger.BeginScopeImpl("Scope1");
// Assert
Assert.NotNull(disposable);
}
/// <summary>
/// Creates a logger that writes to the system event log.
/// </summary>
/// <param name="log">The system log that receives logged
/// messages.</param>
/// <returns>Logger instance.</returns>
/// <exception cref="ArgumentNullException">If <paramref name="log"/>
/// is a null reference.</exception>
public static ILogger CreateSysEventLogger(EventLog log)
{
if (log == null)
{
throw new ArgumentNullException("log");
}
var logger = new EventLogLogger(log);
return(new BitFactoryLogger(logger));
}
public void CallingBeginScopeOnLogger_ReturnsNonNullableInstance()
{
// Arrange
var logger = new EventLogLogger("Test", new EventLogSettings());
// Act
var disposable = logger.BeginScope("Scope1");
// Assert
Assert.NotNull(disposable);
}
private static void EnterEndlessCycle()
{
EventLogLogger.Write(EventLogEntryType.Information, "Onyx successfully initialized, awaiting for commands @ {0}...", OnyxServiceHost <IOnyxLoaderContract> .GeneratePipeUri(m_process.Id));
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
// Если не использовать подобный цикл, то при выгрузке последнего домена целевая программа вылетает
//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
while (true)
{
Thread.Sleep(100);
}
}
public void Constructor_CreatesWindowsEventLog_WithExpectedInformation()
{
// Arrange & Act
var eventLogLogger = new EventLogLogger("Test", new EventLogSettings());
// Assert
var windowsEventLog = Assert.IsType <WindowsEventLog>(eventLogLogger.EventLog);
Assert.Equal("Application", windowsEventLog.DiagnosticsEventLog.Log);
Assert.Equal("Application", windowsEventLog.DiagnosticsEventLog.Source);
Assert.Equal(".", windowsEventLog.DiagnosticsEventLog.MachineName);
}
/// <summary>
/// Starts the GTA process.
/// </summary>
private void StartGTAProcess()
{
Process process;
ProcessProvider provider;
provider = new ProcessProvider();
if (provider.GetGrandTheftAutoProcess() != null)
{
EventLogLogger.LogError("Unable to start the GTA V process as it is already running.");
throw new ApplicationException("Unable to start the GTA V process as it is already running.");
}
if (_config.IsSteamGame)
{
string steamPath;
steamPath = RegistryHelper.GetSteamPath();
if (!string.IsNullOrEmpty(steamPath))
{
process = new Process();
process.StartInfo.FileName = $"{steamPath}\\Steam.exe";
process.StartInfo.Arguments = "-applaunch 271590 -StraightIntoFreemode";
process.Start();
}
else
{
throw new ArgumentException("Unable to find the Steam installation path in the registry.");
}
}
else
{
string installPath;
installPath = RegistryHelper.GetGTASocialClubInstallPath();
if (!string.IsNullOrEmpty(installPath))
{
process = new Process();
process.StartInfo.FileName = $"{installPath}\\PlayGTAV.exe";
process.StartInfo.Arguments = "-StraightIntoFreemode";
process.Start();
}
else
{
throw new ArgumentException("Unable to find the PlayGTAV installation path in the registry.");
}
}
}
public void EventLogLoggerPropertyTest2()
{
SharePointLogger logger = new SharePointLogger();
IEventLogLogger iELogger = logger.EventLogLogger;
EventLogLogger elogger = (EventLogLogger)logger.EventLogLogger;
Assert.AreEqual(iELogger.GetType(), elogger.GetType());
logger = null;
iELogger = null;
elogger = null;
}
public TestObjectFactory(string name, string source)
{
try
{
Name = name;
Source = source;
Logger = new EventLogLogger(Source, Name);
}
catch (Exception)
{
Assert.Inconclusive("could not create tested object.");
}
}
public void CallingBeginScopeOnLogger_AlwaysReturnsNewDisposableInstance()
{
// Arrange
var logger = new EventLogLogger("Test");
// Act
var disposable1 = logger.BeginScopeImpl("Scope1");
var disposable2 = logger.BeginScopeImpl("Scope2");
// Assert
Assert.NotNull(disposable1);
Assert.NotNull(disposable2);
Assert.NotSame(disposable1, disposable2);
}
public void CallingBeginScopeOnLogger_AlwaysReturnsNewDisposableInstance()
{
// Arrange
var logger = new EventLogLogger("Test");
// Act
var disposable1 = logger.BeginScopeImpl("Scope1");
var disposable2 = logger.BeginScopeImpl("Scope2");
// Assert
Assert.NotNull(disposable1);
Assert.NotNull(disposable2);
Assert.NotSame(disposable1, disposable2);
}
public static int Main(string _args)
{
try
{
EventLogLogger.Write(EventLogEntryType.Information, "OnyxLoader loaded successfully into {0} #{1}", m_process, m_process.Id);
InitializeLoggingSubsystem();
InitializeWcfHost();
EnterEndlessCycle();
return(0);
}
catch (Exception ex)
{
EventLogLogger.Write(EventLogEntryType.Error, "Exception occurred during initialization: {0}\r\n{1}", ex, ex.StackTrace);
return(-1);
}
}
public static void IsEnabledReturnsCorrectValue()
{
// Arrange
var logger = new EventLogLogger("Test", new EventLogSettings()
{
Filter = (s, level) => level >= LogLevel.Warning
});
// Assert
Assert.False(logger.IsEnabled(LogLevel.None));
Assert.True(logger.IsEnabled(LogLevel.Critical));
Assert.True(logger.IsEnabled(LogLevel.Error));
Assert.True(logger.IsEnabled(LogLevel.Warning));
Assert.False(logger.IsEnabled(LogLevel.Information));
Assert.False(logger.IsEnabled(LogLevel.Debug));
Assert.False(logger.IsEnabled(LogLevel.Trace));
}
public void MessageExceedingMaxSize_WritesSplitMessages(int messageSize, string[] expectedMessages)
{
// Arrange
var loggerName = "Test";
var maxMessageSize = 10;
var message = new string('a', messageSize);
var testEventLog = new TestEventLog(maxMessageSize);
var logger = new EventLogLogger(loggerName, new EventLogSettings()
{
EventLog = testEventLog
});
// Act
logger.LogInformation(message);
// Assert
Assert.Equal(expectedMessages.Length, testEventLog.Messages.Count);
Assert.Equal(expectedMessages, testEventLog.Messages);
}
public void EventLogLogger_WarnLevel_EventLogEntryTypeUsedTest()
{
//Arrange
var messages = new List <Tuple <string, string, EventLogEntryType> >();
var logger = new EventLogLogger("Test")
{
WriteEntryToEventLog = (x, y, z) => messages.Add(new Tuple <string, string, EventLogEntryType>(x, y, z))
};
var testMessage = "Test message";
var testException = new Exception("Test");
//Act
logger.IsWarnEnabled = true;
logger.Warn(testMessage);
logger.Warn(testException);
logger.Warn(testMessage, testException);
//Assert
Assert.AreEqual(3, messages.Select(x => x).Count(x => x.Item3 == EventLogEntryType.Warning));
}
public void MessageWithinMaxSize_WritesFullMessage(int messageSize)
{
// Arrange
var loggerName = "Test";
var maxMessageSize = 50 + loggerName.Length + Environment.NewLine.Length;
var message = new string('a', messageSize);
var expectedMessage = loggerName + Environment.NewLine + message;
var testEventLog = new TestEventLog(maxMessageSize);
var logger = new EventLogLogger(loggerName, new EventLogSettings()
{
EventLog = testEventLog
});
// Act
logger.LogInformation(message);
// Assert
Assert.Single(testEventLog.Messages);
Assert.Equal(expectedMessage, testEventLog.Messages[0]);
}
public void MessageExceedingMaxSize_WritesSplitMessages(int messageSize, string[] expectedMessages)
{
// Arrange
var headerLength = "EventId: 0".Length + "Category: ".Length;
var loggerName = "Test";
var maxMessageSize = headerLength + loggerName.Length + Environment.NewLine.Length * 3;
var message = new string('a', messageSize);
var testEventLog = new TestEventLog(maxMessageSize);
var logger = new EventLogLogger(loggerName, new EventLogSettings()
{
EventLog = testEventLog
}, new LoggerExternalScopeProvider());
// Act
logger.LogInformation(message);
// Assert
Assert.Equal(expectedMessages.Length, testEventLog.Messages.Count);
Assert.Equal(expectedMessages, testEventLog.Messages);
}
public void Constructor_CreatesWindowsEventLog_WithSuppliedEventLogSettings()
{
// Arrange
var settings = new EventLogSettings()
{
SourceName = "foo",
LogName = "bar",
MachineName = "blah",
EventLog = null
};
// Act
var eventLogLogger = new EventLogLogger("Test", settings);
// Assert
var windowsEventLog = Assert.IsType <WindowsEventLog>(eventLogLogger.EventLog);
Assert.Equal(settings.LogName, windowsEventLog.DiagnosticsEventLog.Log);
Assert.Equal(settings.SourceName, windowsEventLog.DiagnosticsEventLog.Source);
Assert.Equal(settings.MachineName, windowsEventLog.DiagnosticsEventLog.MachineName);
}
public JeanService()
{
logger = new EventLogLogger();
logger.Initialize("Jean");
try
{
loadingError = false;
startupError = true;
LoadSettings();
callbackSemaphore = new Semaphore(0, 1);
startSemaphore = new Semaphore(0, 1);
processingThread = new Thread(this.EventProcessingLoop);
processingThread.Start();
}
catch (Exception e)
{
loadingError = true;
logger.Exception("Jean could not be loaded.", e);
}
logger.Information("Jean was loaded");
}
