Org.Lwes/Diagnostics.cs

   1 #region Header
   2
   3 //
   4 // This file is part of the LWES .NET Binding (LWES.net)
   5 //
   6 // COPYRIGHT© 2009, Phillip Clark (cerebralkungfu[at*g mail[dot*com)
   7 //       original .NET implementation
   8 //
   9 // LWES.net is free software: you can redistribute it and/or modify
  10 // it under the terms of the Lesser GNU General Public License as published by
  11 // the Free Software Foundation, either version 3 of the License, or
  12 // (at your option) any later version.
  13 //
  14 // LWES.net is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 // GNU General Public License for more details.
  18 //
  19 // You should have received a copy of the Lesser GNU General Public License
  20 // along with LWES.net.  If not, see <http://www.gnu.org/licenses/>.
  21 //
  22
  23 #endregion Header
  24
  25 namespace Org.Lwes
  26 {
  27         using System;
  28         using System.Collections.Generic;
  29         using System.Diagnostics;
  30         using System.Security;
  31
  32         using Org.Lwes.Config;
  33         using Org.Lwes.Trace;
  34         using Org.Lwes.Trace.Filters;
  35
  36         public static class Diagnostics
  37         {
  38                 #region Fields
  39
  40                 public static readonly string CDiagnosticsConfigSectionName = "diagnostics";
  41
  42                 public static int DefaultTraceEventID = 0;
  43
  44                 static Guid __traceProcessGuid = Guid.NewGuid();
  45                 static String __traceEnvironment;
  46                 static String __traceComponent;
  47                 static String __traceApplication;
  48                 static String __traceDefaultSource;
  49                 static int __traceOsProcess = -1;
  50                 private static Object __lock = new Object();
  51                 private static Dictionary<string, ITraceSourceFilter> __filters = new Dictionary<string, ITraceSourceFilter>();
  52
  53                 #endregion Fields
  54
  55                 #region Constructors
  56
  57                 static Diagnostics()
  58                 {
  59                         LwesConfigurationSection config = LwesConfigurationSection.Current;
  60                         DiagnosticsConfigurationElement diag = config.Diagnostics ?? new DiagnosticsConfigurationElement();
  61
  62                         __traceEnvironment = diag.Environment;
  63                         __traceComponent = diag.Component;
  64                         __traceDefaultSource = diag.DefaultTraceSource;
  65                         __traceApplication = AppDomain.CurrentDomain.SetupInformation.ApplicationName;
  66                         try
  67                         {
  68                                 __traceOsProcess = Process.GetCurrentProcess().Id;
  69                         }
  70                         catch (SecurityException)
  71                         { // Not run with fulltrust, can't get the process Id.
  72                         }
  73                 }
  74
  75                 #endregion Constructors
  76
  77                 #region Methods
  78
  79                 public static void TraceData<T>(this T source, TraceEventType eventType, object data)
  80                 {
  81                         Diagnostics<T>.TraceData(eventType, DefaultTraceEventID, data);
  82                 }
  83
  84                 public static void TraceData<T>(this T source, TraceEventType eventType, Func<object[]> dataGenerator)
  85                 {
  86                         if (Diagnostics<T>.ShouldTrace(eventType))
  87                         {
  88                                 Diagnostics<T>.TraceData(eventType, DefaultTraceEventID, dataGenerator());
  89                         }
  90                 }
  91
  92                 public static void TraceData<T>(this T source, TraceEventType eventType, int id, object data)
  93                 {
  94                         Diagnostics<T>.TraceData(eventType, id, data);
  95                 }
  96
  97                 public static void TraceData<T>(this T source, TraceEventType eventType, params object[] data)
  98                 {
  99                         Diagnostics<T>.TraceData(eventType, DefaultTraceEventID, data);
 100                 }
 101
 102                 public static void TraceData<T>(this T source, TraceEventType eventType, int id, params object[] data)
 103                 {
 104                         Diagnostics<T>.TraceData(eventType, id, data);
 105                 }
 106
 107                 public static void TraceError<T>(this T source, string message)
 108                 {
 109                         Diagnostics<T>.TraceEvent(TraceEventType.Error, DefaultTraceEventID, message);
 110                 }
 111
 112                 public static void TraceError<T>(this T source, int id, string message)
 113                 {
 114                         Diagnostics<T>.TraceEvent(TraceEventType.Error, id, message);
 115                 }
 116
 117                 public static void TraceError<T>(this T source, string format, params object[] args)
 118                 {
 119                         Diagnostics<T>.TraceEvent(TraceEventType.Error, DefaultTraceEventID, format, args);
 120                 }
 121
 122                 public static void TraceError<T>(this T source, int id, string format, params object[] args)
 123                 {
 124                         Diagnostics<T>.TraceEvent(TraceEventType.Error, id, format, args);
 125                 }
 126
 127                 public static void TraceEvent<T>(this T source, TraceEventType eventType, int id)
 128                 {
 129                         Diagnostics<T>.TraceEvent(eventType, id);
 130                 }
 131
 132                 public static void TraceEvent<T>(this T source, TraceEventType eventType, string message)
 133                 {
 134                         Diagnostics<T>.TraceEvent(eventType, DefaultTraceEventID, message);
 135                 }
 136
 137                 public static void TraceEvent<T>(this T source, TraceEventType eventType, int id, string message)
 138                 {
 139                         Diagnostics<T>.TraceEvent(eventType, id, message);
 140                 }
 141
 142                 public static void TraceEvent<T>(this T source, TraceEventType eventType, string format, params object[] args)
 143                 {
 144                         Diagnostics<T>.TraceEvent(eventType, DefaultTraceEventID, format, args);
 145                 }
 146
 147                 public static void TraceEvent<T>(this T source, TraceEventType eventType, int id, string format, params object[] args)
 148                 {
 149                         Diagnostics<T>.TraceEvent(eventType, id, format, args);
 150                 }
 151
 152                 public static void TraceInformation<T>(this T source, string message)
 153                 {
 154                         Diagnostics<T>.TraceEvent(TraceEventType.Information, DefaultTraceEventID, message);
 155                 }
 156
 157                 public static void TraceInformation<T>(this T source, string format, params object[] args)
 158                 {
 159                         Diagnostics<T>.TraceEvent(TraceEventType.Information, DefaultTraceEventID, format, args);
 160                 }
 161
 162                 public static void TraceTransfer<T>(this T source, string message, Guid relatedActivityId)
 163                 {
 164                         Diagnostics<T>.TraceTransfer(DefaultTraceEventID, message, relatedActivityId);
 165                 }
 166
 167                 public static void TraceTransfer<T>(this T source, int id, string message, Guid relatedActivityId)
 168                 {
 169                         Diagnostics<T>.TraceTransfer(id, message, relatedActivityId);
 170                 }
 171
 172                 public static void TraceVerbose<T>(this T source, string message)
 173                 {
 174                         Diagnostics<T>.TraceEvent(TraceEventType.Verbose, DefaultTraceEventID, message);
 175                 }
 176
 177                 public static void TraceVerbose<T>(this T source, int id, string message)
 178                 {
 179                         Diagnostics<T>.TraceEvent(TraceEventType.Verbose, id, message);
 180                 }
 181
 182                 public static void TraceVerbose<T>(this T source, string format, params object[] args)
 183                 {
 184                         Diagnostics<T>.TraceEvent(TraceEventType.Verbose, DefaultTraceEventID, format, args);
 185                 }
 186
 187                 public static void TraceVerbose<T>(this T source, int id, string format, params object[] args)
 188                 {
 189                         Diagnostics<T>.TraceEvent(TraceEventType.Verbose, id, format, args);
 190                 }
 191
 192                 public static void TraceWarning<T>(this T source, string message)
 193                 {
 194                         Diagnostics<T>.TraceEvent(TraceEventType.Warning, DefaultTraceEventID, message);
 195                 }
 196
 197                 public static void TraceWarning<T>(this T source, int id, string message)
 198                 {
 199                         Diagnostics<T>.TraceEvent(TraceEventType.Warning, id, message);
 200                 }
 201
 202                 public static void TraceWarning<T>(this T source, string format, params object[] args)
 203                 {
 204                         Diagnostics<T>.TraceEvent(TraceEventType.Warning, DefaultTraceEventID, format, args);
 205                 }
 206
 207                 public static void TraceWarning<T>(this T source, int id, string format, params object[] args)
 208                 {
 209                         Diagnostics<T>.TraceEvent(TraceEventType.Warning, id, format, args);
 210                 }
 211
 212                 internal static ITraceSourceFilter DiscoverSourceFilter<T>()
 213                 {
 214                         ITraceSourceFilter result;
 215                         string key = String.Intern(typeof(T).Namespace);
 216
 217                         lock (__lock)
 218                         {
 219                                 if (!__filters.TryGetValue(key, out result))
 220                                 {
 221                                         Stack<string> keys = new Stack<string>();
 222                                         TraceSource src = new TraceSource(key);
 223                                         keys.Push(key);
 224                                         while (src.Switch.DisplayName == key)
 225                                         {
 226                                                 int i = key.LastIndexOf('.');
 227                                                 if (i <= 0) break;
 228                                                 key = String.Intern(key.Substring(0, i));
 229                                                 if (__filters.TryGetValue(key, out result))
 230                                                 {
 231                                                         src = result.Source;
 232                                                         break;
 233                                                 }
 234                                                 keys.Push(key);
 235                                                 src = new TraceSource(key);
 236                                         }
 237                                         switch (src.Switch.Level)
 238                                         {
 239                                                 case SourceLevels.ActivityTracing:
 240                                                 case SourceLevels.All:
 241                                                         result = new AllSourceFilter(src);
 242                                                         break;
 243                                                 case SourceLevels.Critical:
 244                                                         result = new CriticalSourceFilter(src);
 245                                                         break;
 246                                                 case SourceLevels.Error:
 247                                                         result = new ErrorSourceFilter(src);
 248                                                         break;
 249                                                 case SourceLevels.Information:
 250                                                         result = new InformationSourceFilter(src);
 251                                                         break;
 252                                                 case SourceLevels.Verbose:
 253                                                         result = new VerboseSourceFilter(src);
 254                                                         break;
 255                                                 case SourceLevels.Warning:
 256                                                         result = new WarningSourceFilter(src);
 257                                                         break;
 258                                                 case SourceLevels.Off:
 259                                                 default:
 260                                                         result = new NullSourceFilter(src);
 261                                                         break;
 262                                         }
 263                                         foreach (string kk in keys)
 264                                         {
 265                                                 __filters.Add(kk, result);
 266                                         }
 267                                 }
 268                         }
 269                         return result;
 270                 }
 271
 272                 #endregion Methods
 273         }
 274
 275         public static class Diagnostics<T>
 276         {
 277                 #region Fields
 278
 279                 const int CDefaultTraceEventID = 0;
 280
 281                 private static ITraceSourceFilter __filter;
 282
 283                 #endregion Fields
 284
 285                 #region Constructors
 286
 287                 static Diagnostics()
 288                 {
 289                         __filter = Diagnostics.DiscoverSourceFilter<T>();
 290                 }
 291
 292                 #endregion Constructors
 293
 294                 #region Properties
 295
 296                 public static TraceSource Source
 297                 {
 298                         get { return __filter.Source; }
 299                 }
 300
 301                 internal static ITraceSourceFilter Filter
 302                 {
 303                         get { return __filter; }
 304                 }
 305
 306                 #endregion Properties
 307
 308                 #region Methods
 309
 310                 public static bool ShouldTrace(TraceEventType eventType)
 311                 {
 312                         return __filter.ShouldTrace(eventType);
 313                 }
 314
 315                 public static void TraceData(TraceEventType eventType, object data)
 316                 {
 317                         if (ShouldTrace(eventType))
 318                                 __filter.TraceData(eventType, CDefaultTraceEventID, data);
 319                 }
 320
 321                 public static void TraceData(TraceEventType eventType, int id, object data)
 322                 {
 323                         if (ShouldTrace(eventType))
 324                                 __filter.TraceData(eventType, id, data);
 325                 }
 326
 327                 public static void TraceData(TraceEventType eventType, params object[] data)
 328                 {
 329                         if (ShouldTrace(eventType))
 330                                 __filter.TraceData(eventType, CDefaultTraceEventID, data);
 331                 }
 332
 333                 public static void TraceData(TraceEventType eventType, int id, params object[] data)
 334                 {
 335                         if (ShouldTrace(eventType))
 336                                 __filter.TraceData(eventType, id, data);
 337                 }
 338
 339                 public static void TraceError(string message)
 340                 {
 341                         if (ShouldTrace(TraceEventType.Error))
 342                                 __filter.TraceEvent(TraceEventType.Error, CDefaultTraceEventID, message);
 343                 }
 344
 345                 public static void TraceError(int id, string message)
 346                 {
 347                         if (ShouldTrace(TraceEventType.Error))
 348                                 __filter.TraceEvent(TraceEventType.Error, id, message);
 349                 }
 350
 351                 public static void TraceError(string format, params object[] args)
 352                 {
 353                         if (ShouldTrace(TraceEventType.Error))
 354                                 __filter.TraceEvent(TraceEventType.Error, CDefaultTraceEventID, format, args);
 355                 }
 356
 357                 public static void TraceError(int id, string format, params object[] args)
 358                 {
 359                         if (ShouldTrace(TraceEventType.Error))
 360                                 __filter.TraceEvent(TraceEventType.Error, id, format, args);
 361                 }
 362
 363                 public static void TraceEvent(TraceEventType eventType, int id)
 364                 {
 365                         if (ShouldTrace(eventType))
 366                                 __filter.TraceEvent(eventType, id);
 367                 }
 368
 369                 public static void TraceEvent(TraceEventType eventType, string message)
 370                 {
 371                         if (ShouldTrace(eventType))
 372                                 __filter.TraceEvent(eventType, CDefaultTraceEventID, message);
 373                 }
 374
 375                 public static void TraceEvent(TraceEventType eventType, int id, string message)
 376                 {
 377                         if (ShouldTrace(eventType))
 378                                 __filter.TraceEvent(eventType, id, message);
 379                 }
 380
 381                 public static void TraceEvent(TraceEventType eventType, string format, params object[] args)
 382                 {
 383                         if (ShouldTrace(eventType))
 384                                 __filter.TraceEvent(eventType, CDefaultTraceEventID, format, args);
 385                 }
 386
 387                 public static void TraceEvent(TraceEventType eventType, int id, string format, params object[] args)
 388                 {
 389                         if (ShouldTrace(eventType))
 390                                 __filter.TraceEvent(eventType, id, format, args);
 391                 }
 392
 393                 public static void TraceInformation(string message)
 394                 {
 395                         if (ShouldTrace(TraceEventType.Information))
 396                                 __filter.TraceEvent(TraceEventType.Information, CDefaultTraceEventID, message);
 397                 }
 398
 399                 public static void TraceInformation(string format, params object[] args)
 400                 {
 401                         if (ShouldTrace(TraceEventType.Information))
 402                                 __filter.TraceEvent(TraceEventType.Information, CDefaultTraceEventID, format, args);
 403                 }
 404
 405                 public static void TraceTransfer(string message, Guid relatedActivityId)
 406                 {
 407                         if (ShouldTrace(TraceEventType.Transfer))
 408                                 __filter.TraceTransfer(CDefaultTraceEventID, message, relatedActivityId);
 409                 }
 410
 411                 public static void TraceTransfer(int id, string message, Guid relatedActivityId)
 412                 {
 413                         if (ShouldTrace(TraceEventType.Transfer))
 414                                 __filter.TraceTransfer(id, message, relatedActivityId);
 415                 }
 416
 417                 public static void TraceVerbose(string message)
 418                 {
 419                         if (ShouldTrace(TraceEventType.Verbose))
 420                                 __filter.TraceEvent(TraceEventType.Verbose, CDefaultTraceEventID, message);
 421                 }
 422
 423                 public static void TraceVerbose(int id, string message)
 424                 {
 425                         if (ShouldTrace(TraceEventType.Verbose))
 426                                 __filter.TraceEvent(TraceEventType.Verbose, id, message);
 427                 }
 428
 429                 public static void TraceVerbose(string format, params object[] args)
 430                 {
 431                         if (ShouldTrace(TraceEventType.Verbose))
 432                                 __filter.TraceEvent(TraceEventType.Verbose, CDefaultTraceEventID, format, args);
 433                 }
 434
 435                 public static void TraceVerbose(int id, string format, params object[] args)
 436                 {
 437                         if (ShouldTrace(TraceEventType.Verbose))
 438                                 __filter.TraceEvent(TraceEventType.Verbose, id, format, args);
 439                 }
 440
 441                 public static void TraceWarning(string message)
 442                 {
 443                         if (ShouldTrace(TraceEventType.Warning))
 444                                 __filter.TraceEvent(TraceEventType.Warning, CDefaultTraceEventID, message);
 445                 }
 446
 447                 public static void TraceWarning(int id, string message)
 448                 {
 449                         if (ShouldTrace(TraceEventType.Warning))
 450                                 __filter.TraceEvent(TraceEventType.Warning, id, message);
 451                 }
 452
 453                 public static void TraceWarning(string format, params object[] args)
 454                 {
 455                         if (ShouldTrace(TraceEventType.Warning))
 456                                 __filter.TraceEvent(TraceEventType.Warning, CDefaultTraceEventID, format, args);
 457                 }
 458
 459                 public static void TraceWarning(int id, string format, params object[] args)
 460                 {
 461                         if (ShouldTrace(TraceEventType.Warning))
 462                                 __filter.TraceEvent(TraceEventType.Warning, id, format, args);
 463                 }
 464
 465                 #endregion Methods
 466         }
 467 }