Services/Logging/Castle.Services.Logging.log4netIntegration/Log4netLogger.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 using Logger = Castle.Core.Logging.ILogger;
  16
  17 namespace Castle.Services.Logging.Log4netIntegration
  18 {
  19         using System;
  20         using log4net;
  21         using log4net.Core;
  22
  23         [Serializable]
  24         public class Log4netLogger : MarshalByRefObject, Logger
  25         {
  26                 private static Type declaringType = typeof(Log4netLogger);
  27
  28                 private ILogger logger;
  29                 private Log4netFactory factory;
  30
  31                 internal Log4netLogger()
  32                 {
  33                 }
  34
  35                 internal Log4netLogger(ILog log, Log4netFactory factory) : this(log.Logger, factory)
  36                 {
  37                 }
  38
  39                 public Log4netLogger(ILogger logger, Log4netFactory factory)
  40                 {
  41                         Logger = logger;
  42                         Factory = factory;
  43                 }
  44
  45                 public virtual Logger CreateChildLogger(String name)
  46                 {
  47                         return Factory.Create(Logger.Name + "." + name);
  48                 }
  49
  50                 protected internal ILogger Logger
  51                 {
  52                         get { return logger; }
  53                         set { logger = value; }
  54                 }
  55
  56                 protected internal Log4netFactory Factory
  57                 {
  58                         get { return factory; }
  59                         set { factory = value; }
  60                 }
  61
  62                 public override string ToString()
  63                 {
  64                         return Logger.ToString();
  65                 }
  66
  67                 #region Debug
  68
  69                 public void Debug(String message)
  70                 {
  71                         if (IsDebugEnabled)
  72                         {
  73                                 Logger.Log(declaringType, Level.Debug, message, null);
  74                         }
  75                 }
  76
  77                 public void Debug(String message, Exception exception)
  78                 {
  79                         if (IsDebugEnabled)
  80                         {
  81                                 Logger.Log(declaringType, Level.Debug, message, exception);
  82                         }
  83                 }
  84
  85                 public void DebugFormat(String format, params Object[] args)
  86                 {
  87                         if (IsDebugEnabled)
  88                         {
  89                                 Logger.Log(declaringType, Level.Debug, String.Format(format, args), null);
  90                         }
  91                 }
  92
  93                 public void DebugFormat(Exception exception, String format, params Object[] args)
  94                 {
  95                         if (IsDebugEnabled)
  96                         {
  97                                 Logger.Log(declaringType, Level.Debug, String.Format(format, args), exception);
  98                         }
  99                 }
 100
 101                 public void DebugFormat(IFormatProvider formatProvider, String format, params Object[] args)
 102                 {
 103                         if (IsDebugEnabled)
 104                         {
 105                                 Logger.Log(declaringType, Level.Debug, String.Format(formatProvider, format, args), null);
 106                         }
 107                 }
 108
 109                 public void DebugFormat(Exception exception, IFormatProvider formatProvider, String format, params Object[] args)
 110                 {
 111                         if (IsDebugEnabled)
 112                         {
 113                                 Logger.Log(declaringType, Level.Debug, String.Format(formatProvider, format, args), exception);
 114                         }
 115                 }
 116
 117                 [Obsolete("Use DebugFormat instead")]
 118                 public void Debug(String format, params object[] args)
 119                 {
 120                         if (IsDebugEnabled)
 121                         {
 122                                 Logger.Log(declaringType, Level.Debug, String.Format(format, args), null);
 123                         }
 124                 }
 125
 126                 #endregion
 127
 128                 #region Info
 129
 130                 public void Info(String message)
 131                 {
 132                         if (IsInfoEnabled)
 133                         {
 134                                 Logger.Log(declaringType, Level.Info, message, null);
 135                         }
 136                 }
 137
 138                 public void Info(String message, Exception exception)
 139                 {
 140                         if (IsInfoEnabled)
 141                         {
 142                                 Logger.Log(declaringType, Level.Info, message, exception);
 143                         }
 144                 }
 145
 146                 public void InfoFormat(String format, params Object[] args)
 147                 {
 148                         if (IsInfoEnabled)
 149                         {
 150                                 Logger.Log(declaringType, Level.Info, String.Format(format, args), null);
 151                         }
 152                 }
 153
 154                 public void InfoFormat(Exception exception, String format, params Object[] args)
 155                 {
 156                         if (IsInfoEnabled)
 157                         {
 158                                 Logger.Log(declaringType, Level.Info, String.Format(format, args), exception);
 159                         }
 160                 }
 161
 162                 public void InfoFormat(IFormatProvider formatProvider, String format, params Object[] args)
 163                 {
 164                         if (IsInfoEnabled)
 165                         {
 166                                 Logger.Log(declaringType, Level.Info, String.Format(formatProvider, format, args), null);
 167                         }
 168                 }
 169
 170                 public void InfoFormat(Exception exception, IFormatProvider formatProvider, String format, params Object[] args)
 171                 {
 172                         if (IsInfoEnabled)
 173                         {
 174                                 Logger.Log(declaringType, Level.Info, String.Format(formatProvider, format, args), exception);
 175                         }
 176                 }
 177
 178                 [Obsolete("Use InfoFormat instead")]
 179                 public void Info(String format, params object[] args)
 180                 {
 181                         if (IsInfoEnabled)
 182                         {
 183                                 Logger.Log(declaringType, Level.Info, String.Format(format, args), null);
 184                         }
 185                 }
 186
 187                 #endregion
 188
 189                 #region Warn
 190
 191                 public void Warn(String message)
 192                 {
 193                         if (IsWarnEnabled)
 194                         {
 195                                 Logger.Log(declaringType, Level.Warn, message, null);
 196                         }
 197                 }
 198
 199                 public void Warn(String message, Exception exception)
 200                 {
 201                         if (IsWarnEnabled)
 202                         {
 203                                 Logger.Log(declaringType, Level.Warn, message, exception);
 204                         }
 205                 }
 206
 207                 public void WarnFormat(String format, params Object[] args)
 208                 {
 209                         if (IsWarnEnabled)
 210                         {
 211                                 Logger.Log(declaringType, Level.Warn, String.Format(format, args), null);
 212                         }
 213                 }
 214
 215                 public void WarnFormat(Exception exception, String format, params Object[] args)
 216                 {
 217                         if (IsWarnEnabled)
 218                         {
 219                                 Logger.Log(declaringType, Level.Warn, String.Format(format, args), exception);
 220                         }
 221                 }
 222
 223                 public void WarnFormat(IFormatProvider formatProvider, String format, params Object[] args)
 224                 {
 225                         if (IsWarnEnabled)
 226                         {
 227                                 Logger.Log(declaringType, Level.Warn, String.Format(formatProvider, format, args), null);
 228                         }
 229                 }
 230
 231                 public void WarnFormat(Exception exception, IFormatProvider formatProvider, String format, params Object[] args)
 232                 {
 233                         if (IsWarnEnabled)
 234                         {
 235                                 Logger.Log(declaringType, Level.Warn, String.Format(formatProvider, format, args), exception);
 236                         }
 237                 }
 238
 239                 [Obsolete("Use WarnFormat instead")]
 240                 public void Warn(String format, params object[] args)
 241                 {
 242                         if (IsWarnEnabled)
 243                         {
 244                                 Logger.Log(declaringType, Level.Warn, String.Format(format, args), null);
 245                         }
 246                 }
 247
 248                 #endregion
 249
 250                 #region Error
 251
 252                 public void Error(String message)
 253                 {
 254                         if (IsErrorEnabled)
 255                         {
 256                                 Logger.Log(declaringType, Level.Error, message, null);
 257                         }
 258                 }
 259
 260                 public void Error(String message, Exception exception)
 261                 {
 262                         if (IsErrorEnabled)
 263                         {
 264                                 Logger.Log(declaringType, Level.Error, message, exception);
 265                         }
 266                 }
 267
 268                 public void ErrorFormat(String format, params Object[] args)
 269                 {
 270                         if (IsErrorEnabled)
 271                         {
 272                                 Logger.Log(declaringType, Level.Error, String.Format(format, args), null);
 273                         }
 274                 }
 275
 276                 public void ErrorFormat(Exception exception, String format, params Object[] args)
 277                 {
 278                         if (IsErrorEnabled)
 279                         {
 280                                 Logger.Log(declaringType, Level.Error, String.Format(format, args), exception);
 281                         }
 282                 }
 283
 284                 public void ErrorFormat(IFormatProvider formatProvider, String format, params Object[] args)
 285                 {
 286                         if (IsErrorEnabled)
 287                         {
 288                                 Logger.Log(declaringType, Level.Error, String.Format(formatProvider, format, args), null);
 289                         }
 290                 }
 291
 292                 public void ErrorFormat(Exception exception, IFormatProvider formatProvider, String format, params Object[] args)
 293                 {
 294                         if (IsErrorEnabled)
 295                         {
 296                                 Logger.Log(declaringType, Level.Error, String.Format(formatProvider, format, args), exception);
 297                         }
 298                 }
 299
 300                 [Obsolete("Use ErrorFormat instead")]
 301                 public void Error(String format, params object[] args)
 302                 {
 303                         if (IsErrorEnabled)
 304                         {
 305                                 Logger.Log(declaringType, Level.Error, String.Format(format, args), null);
 306                         }
 307                 }
 308
 309                 #endregion
 310
 311                 #region Fatal
 312
 313                 public void Fatal(String message)
 314                 {
 315                         if (IsFatalEnabled)
 316                         {
 317                                 Logger.Log(declaringType, Level.Fatal, message, null);
 318                         }
 319                 }
 320
 321                 public void Fatal(String message, Exception exception)
 322                 {
 323                         if (IsFatalEnabled)
 324                         {
 325                                 Logger.Log(declaringType, Level.Fatal, message, exception);
 326                         }
 327                 }
 328
 329                 public void FatalFormat(String format, params Object[] args)
 330                 {
 331                         if (IsFatalEnabled)
 332                         {
 333                                 Logger.Log(declaringType, Level.Fatal, String.Format(format, args), null);
 334                         }
 335                 }
 336
 337                 public void FatalFormat(Exception exception, String format, params Object[] args)
 338                 {
 339                         if (IsFatalEnabled)
 340                         {
 341                                 Logger.Log(declaringType, Level.Fatal, String.Format(format, args), exception);
 342                         }
 343                 }
 344
 345                 public void FatalFormat(IFormatProvider formatProvider, String format, params Object[] args)
 346                 {
 347                         if (IsFatalEnabled)
 348                         {
 349                                 Logger.Log(declaringType, Level.Fatal, String.Format(formatProvider, format, args), null);
 350                         }
 351                 }
 352
 353                 public void FatalFormat(Exception exception, IFormatProvider formatProvider, String format, params Object[] args)
 354                 {
 355                         if (IsFatalEnabled)
 356                         {
 357                                 Logger.Log(declaringType, Level.Fatal, String.Format(formatProvider, format, args), exception);
 358                         }
 359                 }
 360
 361                 [Obsolete("Use FatalFormat instead")]
 362                 public void Fatal(String format, params object[] args)
 363                 {
 364                         if (IsFatalEnabled)
 365                         {
 366                                 Logger.Log(declaringType, Level.Fatal, String.Format(format, args), null);
 367                         }
 368                 }
 369
 370                 #endregion
 371
 372                 #region FatalError (obsolete)
 373
 374                 [Obsolete("Use FatalFormat instead")]
 375                 public void FatalError(String format, params object[] args)
 376                 {
 377                         if (IsFatalErrorEnabled)
 378                         {
 379                                 Logger.Log(declaringType, Level.Fatal, String.Format(format, args), null);
 380                         }
 381                 }
 382
 383                 [Obsolete("Use Fatal instead")]
 384                 public void FatalError(String message, Exception exception)
 385                 {
 386                         if (IsFatalErrorEnabled)
 387                         {
 388                                 Logger.Log(declaringType, Level.Fatal, message, exception);
 389                         }
 390                 }
 391
 392                 [Obsolete("Use Fatal instead")]
 393                 public void FatalError(String message)
 394                 {
 395                         if (IsFatalErrorEnabled)
 396                         {
 397                                 Logger.Log(declaringType, Level.Fatal, message, null);
 398                         }
 399                 }
 400
 401                 #endregion
 402
 403                 #region Is (...) Enabled
 404
 405                 public bool IsErrorEnabled
 406                 {
 407                         get { return Logger.IsEnabledFor(Level.Error); }
 408                 }
 409
 410                 public bool IsWarnEnabled
 411                 {
 412                         get { return Logger.IsEnabledFor(Level.Warn); }
 413                 }
 414
 415                 public bool IsDebugEnabled
 416                 {
 417                         get { return Logger.IsEnabledFor(Level.Debug); }
 418                 }
 419
 420                 public bool IsFatalEnabled
 421                 {
 422                         get { return Logger.IsEnabledFor(Level.Fatal); }
 423                 }
 424
 425                 [Obsolete("Use IsFatalEnabled instead")]
 426                 public bool IsFatalErrorEnabled
 427                 {
 428                         get { return Logger.IsEnabledFor(Level.Fatal); }
 429                 }
 430
 431                 public bool IsInfoEnabled
 432                 {
 433                         get { return Logger.IsEnabledFor(Level.Info); }
 434                 }
 435
 436                 #endregion
 437         }
 438 }