static void Main(string[] args)
{
//
// New-EventLog -source "MySource" -logname "MyLog" (cf. https://technet.microsoft.com/en-us/library/hh849768.aspx)
// Run eventvwr
// Remove-EventLog -logname "MyLog" (cf. https://technet.microsoft.com/en-us/library/hh849786.aspx)
//
WriteLine("Option A");
var eventLog = new EventLog() {Source = "Application"};
eventLog.WriteEntry("Message Option A");
WriteLine("Option B");
var eventLogB = new EventLog() {Source = "MyLog", EnableRaisingEvents = true};
var eventInstanceB = new EventInstance(0, 1);
eventLogB.WriteEvent(eventInstanceB, "Message Option B");
WriteLine("Option C");
var eventLogC = new EventLog() {Source = "MyLog"};
eventLogC.WriteEntry("Message Option C", EventLogEntryType.Error);
WriteLine("Option D");
var eventLogD = new EventLog() {Source = "MySource", EnableRaisingEvents = true};
eventLogD.WriteEntry("Message Option D", EventLogEntryType.Error);
WriteLine("Done.");
ReadLine();
}
protected override void OnEventWritten(EventWrittenEventArgs eventData)
{
var test = new EventInstance(eventData.EventId, (int)eventData.Task, EventLogEntryType.Warning);
_eventLog.WriteEvent(test, new string[] { "OpCode=1" });
_eventLog.WriteEntry("Event Occurring", EventLogEntryType.Information, eventData.EventId, (short)eventData.Task);
}
public static void WriteEvent(long EventId, string EventContent, EventLogEntryType EntryType)
{
try
{
System.Diagnostics.EventInstance theEvtInst = new System.Diagnostics.EventInstance(EventId, 0, EntryType);
//System.Diagnostics.EventLog.WriteEvent(AppCfgs.CurrentAppCenterID + "KeDuoSysLogs", theEvtInst, EventContent, AppCfgs.ServiceBaseAddress);
}
catch
{
}
}
public void Constructor1 ()
{
EventInstance ei = null;
ei = new EventInstance (5, 10);
Assert.AreEqual (10, ei.CategoryId, "#A1");
Assert.AreEqual (5, ei.InstanceId, "#A2");
Assert.AreEqual (EventLogEntryType.Information, ei.EntryType, "#A3");
ei = new EventInstance (0, 0);
Assert.AreEqual (0, ei.CategoryId, "#B1");
Assert.AreEqual (0, ei.InstanceId, "#B2");
Assert.AreEqual (EventLogEntryType.Information, ei.EntryType, "#B3");
ei = new EventInstance (uint.MaxValue, ushort.MaxValue);
Assert.AreEqual (ushort.MaxValue, ei.CategoryId, "#C1");
Assert.AreEqual (uint.MaxValue, ei.InstanceId, "#C2");
Assert.AreEqual (EventLogEntryType.Information, ei.EntryType, "#C3");
}
internal override void LogEngineLifecycleEvent(LogContext logContext, EngineState newState, EngineState previousState)
{
int engineLifecycleEventId = GetEngineLifecycleEventId(newState);
if (engineLifecycleEventId != -1)
{
Hashtable mapArgs = new Hashtable();
mapArgs["NewEngineState"] = newState.ToString();
mapArgs["PreviousEngineState"] = previousState.ToString();
FillEventArgs(mapArgs, logContext);
EventInstance entry = new EventInstance((long) engineLifecycleEventId, 4) {
EntryType = EventLogEntryType.Information
};
string eventDetail = this.GetEventDetail("EngineLifecycleContext", mapArgs);
this.LogEvent(entry, new object[] { newState, previousState, eventDetail });
}
}
internal override void LogCommandLifecycleEvent(Func<LogContext> getLogContext, CommandState newState)
{
LogContext logContext = getLogContext();
int commandLifecycleEventId = GetCommandLifecycleEventId(newState);
if (commandLifecycleEventId != -1)
{
Hashtable mapArgs = new Hashtable();
mapArgs["NewCommandState"] = newState.ToString();
FillEventArgs(mapArgs, logContext);
EventInstance entry = new EventInstance((long) commandLifecycleEventId, 5) {
EntryType = EventLogEntryType.Information
};
string eventDetail = this.GetEventDetail("CommandLifecycleContext", mapArgs);
this.LogEvent(entry, new object[] { logContext.CommandName, newState, eventDetail });
}
}
public static void WriteEvent(string source, System.Diagnostics.EventInstance instance, params object[] values)
{
}
public void WriteEvent4_Values_Null ()
{
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
EventLog.CreateEventSource ("monotempsource", "monologtemp");
try {
byte [] data = new byte [] { 23, 54 };
EventInstance instance = new EventInstance (5, 666,
EventLogEntryType.Warning);
EventLog.WriteEvent ("monotempsource", instance, data, (object) null);
using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
// MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
Assert.IsNotNull (entry, "#B1");
Assert.IsNotNull (entry.Category, "#B2");
Assert.AreEqual ("(666)", entry.Category, "#B3");
Assert.AreEqual (666, entry.CategoryNumber, "#B4");
Assert.IsNotNull (entry.Data, "#B5");
Assert.AreEqual (data, entry.Data, "#B6");
Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
Assert.AreEqual (5, entry.EventID, "#B8");
Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
Assert.IsNotNull (entry.MachineName, "#B10");
Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
Assert.IsNotNull (entry.ReplacementStrings, "#B12");
Assert.AreEqual (1, entry.ReplacementStrings.Length, "#B13");
Assert.AreEqual (string.Empty, entry.ReplacementStrings [0], "#B14");
Assert.IsNotNull (entry.Source, "#B15");
Assert.AreEqual ("monotempsource", entry.Source, "#B16");
Assert.IsNull (entry.UserName, "#B17");
}
} finally {
if (EventLog.Exists ("monologtemp"))
EventLog.Delete ("monologtemp");
}
}
[ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
public void WriteEvent4_Source_Empty ()
{
EventInstance instance = new EventInstance (5, 1,
EventLogEntryType.Information);
EventLog.WriteEvent (string.Empty, instance, new byte [0]);
}
public void WriteEvent2_Source_DoesNotExist ()
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
return;
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
if (EventLog.SourceExists ("monoothersource", "."))
Assert.Ignore ("Event log source 'monoothersource' should not exist.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
EventLog.CreateEventSource ("monoothersource", "monologtemp");
try {
using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
byte [] data = new byte [] { 23, 54 };
EventInstance instance = new EventInstance (5, 1,
EventLogEntryType.Error);
eventLog.WriteEvent (instance, data, "replace1", "replace2");
// MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
Assert.IsNotNull (entry, "#B1");
Assert.IsNotNull (entry.Category, "#B2");
Assert.AreEqual ("(1)", entry.Category, "#B3");
Assert.AreEqual (1, entry.CategoryNumber, "#B4");
Assert.IsNotNull (entry.Data, "#B5");
Assert.AreEqual (data, entry.Data, "#B6");
Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
Assert.AreEqual (5, entry.EventID, "#B8");
Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
Assert.IsNotNull (entry.MachineName, "#B10");
Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
Assert.IsNotNull (entry.ReplacementStrings, "#B12");
Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
Assert.IsNotNull (entry.Source, "#B16");
Assert.AreEqual ("monotempsource", entry.Source, "#B17");
Assert.IsNull (entry.UserName, "#B18");
}
} finally {
if (EventLog.Exists ("monologtemp"))
EventLog.Delete ("monologtemp");
}
}
public void WriteEvent(EventInstance instance, byte[] data, Object[] values)
{
}
/// <summary>
/// The signature of this method does not change, it provides everything you need to know about the
/// log event, you may prepend fixed arguments to the arguments parameters, then simply call write.
/// BTW, since this is called from the formatter method, or from the exception constructor, you may
/// assume the current stack is the execution context for the exception. The exception's StackTrace
/// will be empty since the exception has not been thrown.
/// </summary>
public static void TestCustomEventWriter(string eventLog, string eventSource, int category, EventLogEntryType eventType, long eventId, object[] arguments, Exception error)
{
_lastLog = new EventLog(eventLog, ".", eventSource);
_lastEvent = new EventInstance(eventId, category, eventType);
_lastArgs = (string[])arguments;
}
public void TestFormatResxOptions()
{
TestResourceBuilder builder = new TestResourceBuilder("TestNs", "ResXClass");
//the next message id to use when autoLog is enabled.
builder.Add(".NextMessageId", 5);
//the format string for the full hresult to a uri.
builder.Add(".HelpLink", new Uri("http://mydomain/errorcodes.aspx?id={0:x8}"));
//Trailing message text for event log, can include {0} formats. which are specified before the message-specific values
builder.Add(".EventMessageFormat", "Trailing message text for event log, can include {0} formats.");
//Enables the LOG feature to automagically generate log calls on all exception constructors.
builder.Add(".AutoLog", true);
//The fully-qualified method used to write the log to the event log
builder.Add(".AutoLogMethod", String.Format("{0}.TestCustomEventWriter", GetType().FullName));
//The name of the event source to register, can be qualified with log: "Log-Name/Event-Source"
builder.Add(".EventSource", "Application/YourAppName");
//OPTIONAL (default=0): The category id and name for the category of the message, should be unique for this ResX file
builder.Add(".EventCategory", 0x0F, "MyCategory");
//OPTIONAL (default=0): The facility code (256-2047) and name to define for these messages
builder.Add(".Facility", 258, "MyFacility");
builder.Add("TestFormatting(int value)", "TestFormatting-{0:x8}", "#MessageId=3");
builder.Add("TestWarning", "TestWarning", "(int unprinted) #MessageId=251, Severity=Warn");
builder.Add("TestException(string s, int i)", "TestException-{0}-{1}", ":System.Runtime.InteropServices.COMException");
string code, resx;
TestResourceResult result;
StringWriter captureErr = new StringWriter();
TextWriter stderr = Console.Error;
try
{
Console.SetError(captureErr);
result = builder.Compile("-reference:" + GetType().Assembly.Location, out code, out resx);
}
finally { Console.SetError(stderr); }
_lastEvent = null;
Assert.AreEqual("TestFormatting-000e1234", result.GetValue("TestFormatting", 0x0e1234));
Assert.IsNotNull(_lastEvent);
Assert.AreEqual("Application", _lastLog.Log);
Assert.AreEqual("YourAppName", _lastLog.Source);
Assert.AreEqual(0x0F, _lastEvent.CategoryId);
Assert.AreEqual(EventLogEntryType.Information, _lastEvent.EntryType);
Assert.AreEqual(0x41020003L, _lastEvent.InstanceId);
Assert.AreEqual(1, _lastArgs.Length);
Assert.AreEqual("000e1234", _lastArgs[0]);
_lastEvent = null;
Assert.AreEqual("TestWarning", result.GetValue("TestWarning", 3579));
Assert.IsNotNull(_lastEvent);
Assert.AreEqual("Application", _lastLog.Log);
Assert.AreEqual("YourAppName", _lastLog.Source);
Assert.AreEqual(0x0F, _lastEvent.CategoryId);
Assert.AreEqual(EventLogEntryType.Warning, _lastEvent.EntryType);
Assert.AreEqual(0x810200fbL, _lastEvent.InstanceId);
Assert.AreEqual(1, _lastArgs.Length);
Assert.AreEqual("3579", _lastArgs[0]);
_lastEvent = null;
COMException error = (COMException)result.CreateException("TestException", "error", 1234);
Assert.AreEqual("TestException-error-1234", error.Message);
Assert.AreEqual(unchecked((int)0xe1020005), error.ErrorCode);//5 was auto-assigned by NextMessageId
Assert.AreEqual("http://mydomain/errorcodes.aspx?id=e1020005", error.HelpLink);
Assert.IsNotNull(_lastEvent);
Assert.AreEqual("Application", _lastLog.Log);
Assert.AreEqual("YourAppName", _lastLog.Source);
Assert.AreEqual(0x0F, _lastEvent.CategoryId);
Assert.AreEqual(EventLogEntryType.Error, _lastEvent.EntryType);
Assert.AreEqual(0xC1020005L, _lastEvent.InstanceId);
Assert.AreEqual(2, _lastArgs.Length);
Assert.AreEqual("error", _lastArgs[0]);
Assert.AreEqual("1234", _lastArgs[1]);
}
public static void WriteEvent(string source, EventInstance instance, byte[] data, Object[] values)
{
Contract.Ensures(0 <= source.Length);
Contract.Ensures(source.Length <= 212);
}
public static void WriteEvent(string source, EventInstance instance, byte[] data, params object[] values)
{
throw new NotImplementedException();
}
public void WriteEvent(EventInstance instance, params object[] values)
{
throw new NotImplementedException();
}
private void LogPipelineExecutionDetailEvent(LogContext logContext, string pipelineExecutionDetail, int detailSequence, int detailTotal)
{
int num = 800;
Hashtable mapArgs = new Hashtable();
mapArgs["PipelineExecutionDetail"] = pipelineExecutionDetail;
mapArgs["DetailSequence"] = detailSequence;
mapArgs["DetailTotal"] = detailTotal;
FillEventArgs(mapArgs, logContext);
EventInstance entry = new EventInstance((long) num, 8) {
EntryType = EventLogEntryType.Information
};
string eventDetail = this.GetEventDetail("PipelineExecutionDetailContext", mapArgs);
this.LogEvent(entry, new object[] { logContext.CommandLine, eventDetail, pipelineExecutionDetail });
}
public void WriteEvent2_Data_Null ()
{
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
EventLog.CreateEventSource ("monotempsource", "monologtemp");
try {
using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
EventInstance instance = new EventInstance (5, 444,
EventLogEntryType.Warning);
eventLog.WriteEvent (instance, null, "replace1", null, "replace3");
// MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
Assert.IsNotNull (entry, "#B1");
Assert.IsNotNull (entry.Category, "#B2");
Assert.AreEqual ("(444)", entry.Category, "#B3");
Assert.AreEqual (444, entry.CategoryNumber, "#B4");
Assert.IsNotNull (entry.Data, "#B5");
Assert.AreEqual (0, entry.Data.Length, "#B6");
Assert.AreEqual (EventLogEntryType.Warning, entry.EntryType, "#B7");
Assert.AreEqual (5, entry.EventID, "#B8");
Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
Assert.IsNotNull (entry.MachineName, "#B10");
Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
Assert.IsNotNull (entry.ReplacementStrings, "#B12");
Assert.AreEqual (3, entry.ReplacementStrings.Length, "#B13");
Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
Assert.AreEqual (string.Empty, entry.ReplacementStrings [1], "#B15");
Assert.AreEqual ("replace3", entry.ReplacementStrings [2], "#B16");
Assert.IsNotNull (entry.Source, "#B17");
Assert.AreEqual ("monotempsource", entry.Source, "#B18");
Assert.IsNull (entry.UserName, "#B19");
}
} finally {
if (EventLog.Exists ("monologtemp"))
EventLog.Delete ("monologtemp");
}
}
internal override void LogProviderLifecycleEvent(LogContext logContext, string providerName, ProviderState newState)
{
int providerLifecycleEventId = GetProviderLifecycleEventId(newState);
if (providerLifecycleEventId != -1)
{
Hashtable mapArgs = new Hashtable();
mapArgs["ProviderName"] = providerName;
mapArgs["NewProviderState"] = newState.ToString();
FillEventArgs(mapArgs, logContext);
EventInstance entry = new EventInstance((long) providerLifecycleEventId, 6) {
EntryType = EventLogEntryType.Information
};
string eventDetail = this.GetEventDetail("ProviderLifecycleContext", mapArgs);
this.LogEvent(entry, new object[] { providerName, newState, eventDetail });
}
}
public void WriteEvent(EventInstance instance, Object[] values)
{
}
public void WriteEvent(EventInstance instance, Object[] values)
{
}
public void WriteEvent (EventInstance instance, byte [] data, params object [] values)
{
if (instance == null)
throw new ArgumentNullException ("instance");
string [] replacementStrings = null;
if (values != null) {
replacementStrings = new string [values.Length];
for (int i = 0; i < values.Length; i++) {
object value = values [i];
if (value == null)
replacementStrings [i] = string.Empty;
else
replacementStrings [i] = values [i].ToString ();
}
} else {
replacementStrings = new string [0];
}
WriteEntry (replacementStrings, instance.EntryType, instance
.InstanceId, (short) instance.CategoryId, data);
}
[ExpectedException (typeof (ArgumentException))] // Source property was not set before writing to the event log
public void WriteEvent2_Source_Empty ()
{
using (EventLog eventLog = new EventLog ("monologtemp")) {
EventInstance instance = new EventInstance (5, 1,
EventLogEntryType.Information);
eventLog.WriteEvent (instance, new byte [0], "replace");
}
}
public static void WriteEvent (string source, EventInstance instance, params object [] values)
{
WriteEvent (source, instance, null, values);
}
public void WriteEvent4 ()
{
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
EventLog.CreateEventSource ("monotempsource", "monologtemp");
try {
byte [] data = new byte [] { 23, 54 };
EventInstance instance = new EventInstance (5, 666,
EventLogEntryType.FailureAudit);
EventLog.WriteEvent ("monotempsource", instance, data, 5, "new"
+ Environment.NewLine + "line", true, null);
using (EventLog eventLog = new EventLog ("monologtemp", ".", "monotempsource")) {
// MSBUG: Assert.AreEqual (1, eventLog.Entries.Count, "#A1");
Assert.AreEqual ("monologtemp", eventLog.Log, "#A2");
Assert.AreEqual ("monotempsource", eventLog.Source, "#A3");
Assert.IsTrue (EventLog.Exists ("monologtemp"), "#A4");
Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A5");
Assert.IsTrue (EventLog.SourceExists ("monologtemp"), "#A6");
Assert.AreEqual ("monologtemp", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A7");
EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
Assert.IsNotNull (entry, "#B1");
Assert.IsNotNull (entry.Category, "#B2");
Assert.AreEqual ("(666)", entry.Category, "#B3");
Assert.AreEqual (666, entry.CategoryNumber, "#B4");
Assert.IsNotNull (entry.Data, "#B5");
Assert.AreEqual (data, entry.Data, "#B6");
Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#B7");
Assert.AreEqual (5, entry.EventID, "#B8");
Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
Assert.IsNotNull (entry.MachineName, "#B10");
Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
Assert.IsNotNull (entry.ReplacementStrings, "#B12");
Assert.AreEqual (4, entry.ReplacementStrings.Length, "#B13");
Assert.AreEqual ("5", entry.ReplacementStrings [0], "#B14");
Assert.AreEqual ("new" + Environment.NewLine + "line", entry.ReplacementStrings [1], "#B15");
Assert.AreEqual (true.ToString (), entry.ReplacementStrings [2], "#B16");
Assert.AreEqual (string.Empty, entry.ReplacementStrings [3], "#B17");
Assert.IsNotNull (entry.Source, "#B18");
Assert.AreEqual ("monotempsource", entry.Source, "#B19");
Assert.IsNull (entry.UserName, "#B20");
EventLog.WriteEvent ("monotempsource", instance, data);
entry = eventLog.Entries [eventLog.Entries.Count - 1];
Assert.IsNotNull (entry, "#C1");
Assert.IsNotNull (entry.Category, "#C2");
Assert.AreEqual ("(666)", entry.Category, "#C3");
Assert.AreEqual (666, entry.CategoryNumber, "#C4");
Assert.IsNotNull (entry.Data, "#C5");
Assert.AreEqual (data, entry.Data, "#C6");
Assert.AreEqual (EventLogEntryType.FailureAudit, entry.EntryType, "#C7");
Assert.AreEqual (5, entry.EventID, "#C8");
Assert.AreEqual (entry.EventID, entry.InstanceId, "#C9");
Assert.IsNotNull (entry.MachineName, "#C10");
Assert.AreEqual (Environment.MachineName, entry.MachineName, "#C11");
Assert.IsNotNull (entry.ReplacementStrings, "#C12");
Assert.AreEqual (0, entry.ReplacementStrings.Length, "#C13");
Assert.IsNotNull (entry.Source, "#C14");
Assert.AreEqual ("monotempsource", entry.Source, "#C15");
Assert.IsNull (entry.UserName, "#C16");
}
} finally {
if (EventLog.Exists ("monologtemp"))
EventLog.Delete ("monologtemp");
}
}
public static void WriteEvent (string source, EventInstance instance, byte [] data, params object [] values)
{
using (EventLog eventLog = new EventLog ()) {
eventLog.Source = source;
eventLog.WriteEvent (instance, data, values);
}
}
public void WriteEvent4_Source_DoesNotExist ()
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
return;
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
bool applicationLogExists = EventLog.Exists ("Application");
try {
byte [] data = new byte [] { 23, 54 };
EventInstance instance = new EventInstance (666, 1,
EventLogEntryType.Error);
EventLog.WriteEvent ("monotempsource", instance, data, "replace1", "replace2");
Assert.IsTrue (EventLog.Exists ("Application"), "#A1");
Assert.IsTrue (EventLog.SourceExists ("monotempsource"), "#A2");
Assert.AreEqual ("Application", EventLog.LogNameFromSourceName ("monotempsource", "."), "#A3");
if (EventLogImplType == WIN32_IMPL)
// win32 API does not return entries in order for
// Application log
return;
using (EventLog eventLog = new EventLog ("Application", ".", "monotempsource")) {
EventLogEntry entry = eventLog.Entries [eventLog.Entries.Count - 1];
Assert.IsNotNull (entry, "#B1");
Assert.IsNotNull (entry.Category, "#B2");
Assert.AreEqual ("(1)", entry.Category, "#B3");
Assert.AreEqual (1, entry.CategoryNumber, "#B4");
Assert.IsNotNull (entry.Data, "#B5");
Assert.AreEqual (data, entry.Data, "#B6");
Assert.AreEqual (EventLogEntryType.Error, entry.EntryType, "#B7");
Assert.AreEqual (666, entry.EventID, "#B8");
Assert.AreEqual (entry.EventID, entry.InstanceId, "#B9");
Assert.IsNotNull (entry.MachineName, "#B10");
Assert.AreEqual (Environment.MachineName, entry.MachineName, "#B11");
Assert.IsNotNull (entry.ReplacementStrings, "#B12");
Assert.AreEqual (2, entry.ReplacementStrings.Length, "#B13");
Assert.AreEqual ("replace1", entry.ReplacementStrings [0], "#B14");
Assert.AreEqual ("replace2", entry.ReplacementStrings [1], "#B15");
Assert.IsNotNull (entry.Source, "#B16");
Assert.AreEqual ("monotempsource", entry.Source, "#B17");
Assert.IsNull (entry.UserName, "#B18");
}
} finally {
if (!applicationLogExists) {
if (EventLog.Exists ("Application"))
EventLog.Delete ("Application");
} else {
if (EventLog.SourceExists ("monotempsource", "."))
EventLog.DeleteEventSource ("monotempsource", ".");
}
}
}
private EventInstance CreateEventInstance(TraceEventType severity, int id)
{
if (id > 0xffff)
{
id = 0xffff;
}
if (id < 0)
{
id = 0;
}
EventInstance instance1 = new EventInstance((long)id, 0);
if ((severity == TraceEventType.Error) || (severity == TraceEventType.Critical))
{
instance1.EntryType = EventLogEntryType.Error;
return instance1;
}
if (severity == TraceEventType.Warning)
{
instance1.EntryType = EventLogEntryType.Warning;
return instance1;
}
instance1.EntryType = EventLogEntryType.Information;
return instance1;
}
public void WriteEvent(System.Diagnostics.EventInstance instance, params object[] values)
{
}
public void WriteEvent(EventInstance instance, params object [] values)
{
WriteEvent(instance, null, values);
}
private EventInstance CreateEventInstance(TraceEventType severity, int id) {
// Win32 EventLog has an implicit cap at ushort.MaxValue
// We need to cap this explicitly to prevent larger value
// being wrongly casted
if (id > ushort.MaxValue)
id = ushort.MaxValue;
// Ideally we need to pick a value other than '0' as zero is
// a commonly used EventId by most applications
if (id < ushort.MinValue)
id = ushort.MinValue;
EventInstance data = new EventInstance(id, 0);
if (severity == TraceEventType.Error || severity == TraceEventType.Critical)
data.EntryType = EventLogEntryType.Error;
else if (severity == TraceEventType.Warning)
data.EntryType = EventLogEntryType.Warning;
else
data.EntryType = EventLogEntryType.Information;
return data;
}
public static void WriteEvent(string source, EventInstance instance, params object [] values)
{
WriteEvent(source, instance, null, values);
}
internal override void LogEngineHealthEvent(LogContext logContext, int eventId, Exception exception, Dictionary<string, string> additionalInfo)
{
Hashtable mapArgs = new Hashtable();
IContainsErrorRecord record = exception as IContainsErrorRecord;
if ((record != null) && (record.ErrorRecord != null))
{
mapArgs["ExceptionClass"] = exception.GetType().Name;
mapArgs["ErrorCategory"] = record.ErrorRecord.CategoryInfo.Category;
mapArgs["ErrorId"] = record.ErrorRecord.FullyQualifiedErrorId;
if (record.ErrorRecord.ErrorDetails != null)
{
mapArgs["ErrorMessage"] = record.ErrorRecord.ErrorDetails.Message;
}
else
{
mapArgs["ErrorMessage"] = exception.Message;
}
}
else
{
mapArgs["ExceptionClass"] = exception.GetType().Name;
mapArgs["ErrorCategory"] = "";
mapArgs["ErrorId"] = "";
mapArgs["ErrorMessage"] = exception.Message;
}
FillEventArgs(mapArgs, logContext);
FillEventArgs(mapArgs, additionalInfo);
EventInstance entry = new EventInstance((long) eventId, 1) {
EntryType = GetEventLogEntryType(logContext)
};
string eventDetail = this.GetEventDetail("EngineHealthContext", mapArgs);
this.LogEvent(entry, new object[] { mapArgs["ErrorMessage"], eventDetail });
}
public void WriteEvent(EventInstance instance, params Object[] values) {
WriteEvent(instance, null, values);
}
private void LogEvent(EventInstance entry, params object[] args)
{
try
{
this._eventLog.WriteEvent(entry, args);
}
catch (ArgumentException)
{
}
catch (InvalidOperationException)
{
}
catch (Win32Exception)
{
}
}
public void WriteEvent(EventInstance instance, byte[] data, params Object[] values) {
if (instance == null)
throw new ArgumentNullException("instance");
if (Source.Length == 0)
throw new ArgumentException(SR.GetString(SR.NeedSourceToWrite));
string currentMachineName = machineName;
if (!boolFlags[Flag_writeGranted]) {
EventLogPermission permission = new EventLogPermission(EventLogPermissionAccess.Write, currentMachineName);
permission.Demand();
boolFlags[Flag_writeGranted] = true;
}
VerifyAndCreateSource(Source, currentMachineName);
string[] strings = null;
if (values != null) {
strings = new string[values.Length];
for (int i=0; i<values.Length; i++) {
if (values[i] != null)
strings[i] = values[i].ToString();
else
strings[i] = String.Empty;
}
}
InternalWriteEvent((uint) instance.InstanceId, (ushort) instance.CategoryId, instance.EntryType, strings, data, currentMachineName);
}
internal override void LogProviderHealthEvent(LogContext logContext, string providerName, Exception exception)
{
int num = 300;
Hashtable mapArgs = new Hashtable();
mapArgs["ProviderName"] = providerName;
IContainsErrorRecord record = exception as IContainsErrorRecord;
if ((record != null) && (record.ErrorRecord != null))
{
mapArgs["ExceptionClass"] = exception.GetType().Name;
mapArgs["ErrorCategory"] = record.ErrorRecord.CategoryInfo.Category;
mapArgs["ErrorId"] = record.ErrorRecord.FullyQualifiedErrorId;
if ((record.ErrorRecord.ErrorDetails != null) && !string.IsNullOrEmpty(record.ErrorRecord.ErrorDetails.Message))
{
mapArgs["ErrorMessage"] = record.ErrorRecord.ErrorDetails.Message;
}
else
{
mapArgs["ErrorMessage"] = exception.Message;
}
}
else
{
mapArgs["ExceptionClass"] = exception.GetType().Name;
mapArgs["ErrorCategory"] = "";
mapArgs["ErrorId"] = "";
mapArgs["ErrorMessage"] = exception.Message;
}
FillEventArgs(mapArgs, logContext);
EventInstance entry = new EventInstance((long) num, 3) {
EntryType = GetEventLogEntryType(logContext)
};
string eventDetail = this.GetEventDetail("ProviderHealthContext", mapArgs);
this.LogEvent(entry, new object[] { mapArgs["ErrorMessage"], eventDetail });
}
public void WriteEvent(EventInstance instance, byte[] data, Object[] values)
{
}
internal override void LogSettingsEvent(LogContext logContext, string variableName, string value, string previousValue)
{
int num = 700;
Hashtable mapArgs = new Hashtable();
mapArgs["VariableName"] = variableName;
mapArgs["NewValue"] = value;
mapArgs["PreviousValue"] = previousValue;
FillEventArgs(mapArgs, logContext);
EventInstance entry = new EventInstance((long) num, 7) {
EntryType = EventLogEntryType.Information
};
string eventDetail = this.GetEventDetail("SettingsContext", mapArgs);
this.LogEvent(entry, new object[] { variableName, value, previousValue, eventDetail });
}
public static void WriteEvent(string source, EventInstance instance, byte[] data, Object[] values)
{
Contract.Ensures(0 <= source.Length);
Contract.Ensures(source.Length <= 212);
}
