Core/Castle.Core/Logging/Loggers/DiagnosticsLogger.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Core.Logging
  16 {
  17         #if !SILVERLIGHT
  18
  19         using System;
  20         using System.Diagnostics;
  21
  22         /// <summary>
  23         /// The Logger using standart Diagnostics namespace.
  24         /// </summary>
  25         [Serializable]
  26         public class DiagnosticsLogger : LevelFilteredLogger, IDisposable
  27         {
  28                 private EventLog eventLog;
  29
  30                 /// <summary>
  31                 /// Creates a logger based on <see cref="System.Diagnostics.EventLog"/>.
  32                 /// </summary>
  33                 /// <param name="logName"><see cref="EventLog.Log"/></param>
  34                 public DiagnosticsLogger(string logName) : this(logName, "default")
  35                 {
  36                 }
  37
  38                 /// <summary>
  39                 /// Creates a logger based on <see cref="System.Diagnostics.EventLog"/>.
  40                 /// </summary>
  41                 /// <param name="logName"><see cref="EventLog.Log"/></param>
  42                 /// <param name="source"><see cref="EventLog.Source"/></param>
  43                 public DiagnosticsLogger(string logName, string source) : base(LoggerLevel.Debug)
  44                 {
  45                         // Create the source, if it does not already exist.
  46                         if (!EventLog.SourceExists(source))
  47                         {
  48                                 EventLog.CreateEventSource(source, logName);
  49                         }
  50
  51                         eventLog = new EventLog(logName);
  52                         eventLog.Source = source;
  53                 }
  54
  55                 /// <summary>
  56                 /// Creates a logger based on <see cref="System.Diagnostics.EventLog"/>.
  57                 /// </summary>
  58                 /// <param name="logName"><see cref="EventLog.Log"/></param>
  59                 /// <param name="machineName"><see cref="EventLog.MachineName"/></param>
  60                 /// <param name="source"><see cref="EventLog.Source"/></param>
  61                 public DiagnosticsLogger(string logName, string machineName, string source)
  62                 {
  63                         // Create the source, if it does not already exist.
  64                         if (!EventLog.SourceExists(source, machineName))
  65                         {
  66                                 EventSourceCreationData eventSourceCreationData = new EventSourceCreationData(source, logName);
  67                                 eventSourceCreationData.MachineName = machineName;
  68                                 EventLog.CreateEventSource(eventSourceCreationData);
  69                         }
  70
  71                         eventLog = new EventLog(logName, machineName, source);
  72                 }
  73
  74                 ~DiagnosticsLogger()
  75                 {
  76                         Close(false);
  77                 }
  78
  79                 #region IDisposable Members
  80
  81                 public void Dispose()
  82                 {
  83                         Close(true);
  84                 }
  85
  86                 #endregion
  87
  88                 public void Close()
  89                 {
  90                         Close(true);
  91                 }
  92
  93                 protected void Close(bool supressFinalize)
  94                 {
  95                         if (supressFinalize)
  96                         {
  97                                 GC.SuppressFinalize(this);
  98                         }
  99
 100                         if (eventLog != null)
 101                         {
 102                                 eventLog.Close();
 103                                 eventLog = null;
 104                         }
 105                 }
 106
 107                 public override ILogger CreateChildLogger(string newName)
 108                 {
 109                         return new DiagnosticsLogger(eventLog.Log, eventLog.MachineName, eventLog.Source);
 110                 }
 111
 112                 protected override void Log(LoggerLevel level, string name, string message, Exception exception)
 113                 {
 114                         if (eventLog == null) return; // just in case it was disposed
 115
 116                         EventLogEntryType type = TranslateLevel(level);
 117
 118                         String contentToLog;
 119
 120                         if (exception == null)
 121                         {
 122                                 contentToLog = string.Format("[{0}] '{1}' message: {2}", level.ToString(), name, message);
 123                         }
 124                         else
 125                         {
 126                                 contentToLog = string.Format("[{0}] '{1}' message: {2} exception: {3} {4} {5}",
 127                                                              level.ToString(), name, message, exception.GetType(), exception.Message,
 128                                                              exception.StackTrace);
 129                         }
 130
 131                         eventLog.WriteEntry(contentToLog, type);
 132                 }
 133
 134                 private EventLogEntryType TranslateLevel(LoggerLevel level)
 135                 {
 136                         switch(level)
 137                         {
 138                                 case LoggerLevel.Error:
 139                                 case LoggerLevel.Fatal:
 140                                         return EventLogEntryType.Error;
 141                                 case LoggerLevel.Warn:
 142                                         return EventLogEntryType.Warning;
 143                                 default:
 144                                         return EventLogEntryType.Information;
 145                         }
 146                 }
 147         }
 148         #endif
 149 }