Org.Lwes/Trace/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 (phillip[at*flitbit[dot*org)
   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 // Lesser 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         /// <summary>
  37         /// Diagnostics utility.
  38         /// </summary>
  39         public static class Diagnostics
  40         {
  41                 #region Fields
  42
  43                 /// <summary>
  44                 /// Trace ID used when none was given.
  45                 /// </summary>
  46                 public static int DefaultTraceEventID = 0;
  47
  48                 static Guid __traceProcessGuid = Guid.NewGuid();
  49                 static String __traceEnvironment;
  50                 static String __traceComponent;
  51                 static String __traceApplication;
  52                 static String __traceDefaultSource;
  53                 static int __traceOsProcess = -1;
  54                 private static Object __lock = new Object();
  55                 private static Dictionary<string, ITraceSourceFilter> __filters = new Dictionary<string, ITraceSourceFilter>();
  56
  57                 #endregion Fields
  58
  59                 #region Constructors
  60
  61                 static Diagnostics()
  62                 {
  63                         LwesConfigurationSection config = LwesConfigurationSection.Current;
  64                         DiagnosticsConfigurationElement diag = config.Diagnostics ?? new DiagnosticsConfigurationElement();
  65
  66                         __traceEnvironment = diag.Environment;
  67                         __traceComponent = diag.Component;
  68                         __traceDefaultSource = diag.DefaultTraceSource;
  69                         __traceApplication = AppDomain.CurrentDomain.SetupInformation.ApplicationName;
  70                         try
  71                         {
  72                                 __traceOsProcess = Process.GetCurrentProcess().Id;
  73                         }
  74                         catch (SecurityException)
  75                         { // Not run with fulltrust, can't get the process Id.
  76                         }
  77                 }
  78
  79                 #endregion Constructors
  80
  81                 #region Methods
  82
  83                 public static void TraceData<T>(this T source, TraceEventType eventType, object data)
  84                         where T : ITraceable
  85                 {
  86                         TraceAdapter<T>.Filter.TraceData(eventType, DefaultTraceEventID, data);
  87                 }
  88
  89                 public static void TraceData<T>(this T source, TraceEventType eventType, Func<object[]> dataGenerator)
  90                         where T : ITraceable
  91                 {
  92                         TraceAdapter<T>.Filter.TraceData(eventType, DefaultTraceEventID, dataGenerator());
  93                 }
  94
  95                 public static void TraceData<T>(this T source, TraceEventType eventType, int id, object data)
  96                         where T : ITraceable
  97                 {
  98                         TraceAdapter<T>.Filter.TraceData(eventType, id, data);
  99                 }
 100
 101                 public static void TraceData<T>(this T source, TraceEventType eventType, params object[] data)
 102                         where T : ITraceable
 103                 {
 104                         TraceAdapter<T>.Filter.TraceData(eventType, DefaultTraceEventID, data);
 105                 }
 106
 107                 public static void TraceData<T>(this T source, TraceEventType eventType, int id, params object[] data)
 108                         where T : ITraceable
 109                 {
 110                         TraceAdapter<T>.Filter.TraceData(eventType, id, data);
 111                 }
 112
 113                 public static void TraceData(Type sourceType, TraceEventType eventType, object data)
 114                 {
 115                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 116
 117                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 118                         if (f.ShouldTrace(eventType))
 119                         {
 120                                 f.TraceData(eventType, DefaultTraceEventID, data);
 121                         }
 122                 }
 123
 124                 public static void TraceData(Type sourceType, TraceEventType eventType, Func<object[]> dataGenerator)
 125                 {
 126                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 127
 128                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 129                         if (f.ShouldTrace(eventType))
 130                         {
 131                                 f.TraceData(eventType, DefaultTraceEventID, dataGenerator());
 132                         }
 133                 }
 134
 135                 public static void TraceData(Type sourceType, TraceEventType eventType, int id, object data)
 136                 {
 137                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 138
 139                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 140                         if (f.ShouldTrace(eventType))
 141                         {
 142                                 f.TraceData(eventType, id, data);
 143                         }
 144                 }
 145
 146                 public static void TraceData(Type sourceType, TraceEventType eventType, params object[] data)
 147                 {
 148                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 149
 150                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 151                         if (f.ShouldTrace(eventType))
 152                         {
 153                                 f.TraceData(eventType, DefaultTraceEventID, data);
 154                         }
 155                 }
 156
 157                 public static void TraceData(Type sourceType, TraceEventType eventType, int id, params object[] data)
 158                 {
 159                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 160
 161                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 162                         if (f.ShouldTrace(eventType))
 163                         {
 164                                 f.TraceData(eventType, id, data);
 165                         }
 166                 }
 167
 168                 public static void TraceError<T>(this T source, string message)
 169                         where T : ITraceable
 170                 {
 171                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Error, DefaultTraceEventID, message);
 172                 }
 173
 174                 public static void TraceError<T>(this T source, int id, string message)
 175                         where T : ITraceable
 176                 {
 177                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Error, id, message);
 178                 }
 179
 180                 public static void TraceError<T>(this T source, string format, params object[] args)
 181                         where T : ITraceable
 182                 {
 183                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Error, DefaultTraceEventID, format, args);
 184                 }
 185
 186                 public static void TraceError<T>(this T source, int id, string format, params object[] args)
 187                         where T : ITraceable
 188                 {
 189                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Error, id, format, args);
 190                 }
 191
 192                 public static void TraceError(Type sourceType, string message)
 193                 {
 194                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 195
 196                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 197                         if (f.ShouldTrace(TraceEventType.Error))
 198                         {
 199                                 f.TraceEvent(TraceEventType.Error, DefaultTraceEventID, message);
 200                         }
 201                 }
 202
 203                 public static void TraceError(Type sourceType, int id, string message)
 204                 {
 205                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 206
 207                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 208                         if (f.ShouldTrace(TraceEventType.Error))
 209                         {
 210                                 f.TraceEvent(TraceEventType.Error, id, message);
 211                         }
 212                 }
 213
 214                 public static void TraceError(Type sourceType, string format, params object[] args)
 215                 {
 216                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 217
 218                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 219                         if (f.ShouldTrace(TraceEventType.Error))
 220                         {
 221                                 f.TraceEvent(TraceEventType.Error, DefaultTraceEventID, format, args);
 222                         }
 223                 }
 224
 225                 public static void TraceError(Type sourceType, int id, string format, params object[] args)
 226                 {
 227                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 228
 229                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 230                         if (f.ShouldTrace(TraceEventType.Error))
 231                         {
 232                                 f.TraceEvent(TraceEventType.Error, id, format, args);
 233                         }
 234                 }
 235
 236                 public static void TraceEvent<T>(this T source, TraceEventType eventType, int id)
 237                         where T : ITraceable
 238                 {
 239                         TraceAdapter<T>.Filter.TraceEvent(eventType, id);
 240                 }
 241
 242                 public static void TraceEvent<T>(this T source, TraceEventType eventType, string message)
 243                         where T : ITraceable
 244                 {
 245                         TraceAdapter<T>.Filter.TraceEvent(eventType, DefaultTraceEventID, message);
 246                 }
 247
 248                 public static void TraceEvent<T>(this T source, TraceEventType eventType, int id, string message)
 249                         where T : ITraceable
 250                 {
 251                         TraceAdapter<T>.Filter.TraceEvent(eventType, id, message);
 252                 }
 253
 254                 public static void TraceEvent<T>(this T source, TraceEventType eventType, string format, params object[] args)
 255                         where T : ITraceable
 256                 {
 257                         TraceAdapter<T>.Filter.TraceEvent(eventType, DefaultTraceEventID, format, args);
 258                 }
 259
 260                 public static void TraceEvent<T>(this T source, TraceEventType eventType, int id, string format, params object[] args)
 261                         where T : ITraceable
 262                 {
 263                         TraceAdapter<T>.Filter.TraceEvent(eventType, id, format, args);
 264                 }
 265
 266                 public static void TraceEvent(Type sourceType, TraceEventType eventType, int id)
 267                 {
 268                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 269
 270                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 271                         if (f.ShouldTrace(eventType))
 272                         {
 273                                 f.TraceEvent(eventType, id);
 274                         }
 275                 }
 276
 277                 public static void TraceEvent(Type sourceType, TraceEventType eventType, string message)
 278                 {
 279                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 280
 281                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 282                         if (f.ShouldTrace(eventType))
 283                         {
 284                                 f.TraceEvent(eventType, DefaultTraceEventID, message);
 285                         }
 286                 }
 287
 288                 public static void TraceEvent(Type sourceType, TraceEventType eventType, int id, string message)
 289                 {
 290                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 291
 292                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 293                         if (f.ShouldTrace(eventType))
 294                         {
 295                                 f.TraceEvent(eventType, id, message);
 296                         }
 297                 }
 298
 299                 public static void TraceEvent(Type sourceType, TraceEventType eventType, string format, params object[] args)
 300                 {
 301                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 302
 303                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 304                         if (f.ShouldTrace(eventType))
 305                         {
 306                                 f.TraceEvent(eventType, DefaultTraceEventID, format, args);
 307                         }
 308                 }
 309
 310                 public static void TraceEvent(Type sourceType, TraceEventType eventType, int id, string format, params object[] args)
 311                 {
 312                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 313
 314                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 315                         if (f.ShouldTrace(eventType))
 316                         {
 317                                 f.TraceEvent(eventType, id, format, args);
 318                         }
 319                 }
 320
 321                 public static void TraceInformation<T>(this T source, string message)
 322                         where T : ITraceable
 323                 {
 324                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Information, DefaultTraceEventID, message);
 325                 }
 326
 327                 public static void TraceInformation<T>(this T source, string format, params object[] args)
 328                         where T : ITraceable
 329                 {
 330                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Information, DefaultTraceEventID, format, args);
 331                 }
 332
 333                 public static void TraceInformation(Type sourceType, string message)
 334                 {
 335                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 336
 337                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 338                         if (f.ShouldTrace(TraceEventType.Information))
 339                         {
 340                                 f.TraceEvent(TraceEventType.Information, DefaultTraceEventID, message);
 341                         }
 342                 }
 343
 344                 public static void TraceInformation(Type sourceType, string format, params object[] args)
 345                 {
 346                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 347
 348                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 349                         if (f.ShouldTrace(TraceEventType.Information))
 350                         {
 351                                 f.TraceEvent(TraceEventType.Information, DefaultTraceEventID, format, args);
 352                         }
 353                 }
 354
 355                 public static void TraceTransfer<T>(this T source, string message, Guid relatedActivityId)
 356                         where T : ITraceable
 357                 {
 358                         TraceAdapter<T>.Filter.TraceTransfer(DefaultTraceEventID, message, relatedActivityId);
 359                 }
 360
 361                 public static void TraceTransfer<T>(this T source, int id, string message, Guid relatedActivityId)
 362                         where T : ITraceable
 363                 {
 364                         TraceAdapter<T>.Filter.TraceTransfer(id, message, relatedActivityId);
 365                 }
 366
 367                 public static void TraceTransfer(Type sourceType, string message, Guid relatedActivityId)
 368                 {
 369                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 370
 371                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 372                         if (f.ShouldTrace(TraceEventType.Transfer))
 373                         {
 374                                 f.TraceTransfer(DefaultTraceEventID, message, relatedActivityId);
 375                         }
 376                 }
 377
 378                 public static void TraceTransfer(Type sourceType, int id, string message, Guid relatedActivityId)
 379                 {
 380                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 381
 382                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 383                         if (f.ShouldTrace(TraceEventType.Transfer))
 384                         {
 385                                 f.TraceTransfer(id, message, relatedActivityId);
 386                         }
 387                 }
 388
 389                 public static void TraceVerbose<T>(this T source, string message)
 390                         where T : ITraceable
 391                 {
 392                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Verbose, DefaultTraceEventID, message);
 393                 }
 394
 395                 public static void TraceVerbose<T>(this T source, int id, string message)
 396                         where T : ITraceable
 397                 {
 398                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Verbose, id, message);
 399                 }
 400
 401                 public static void TraceVerbose<T>(this T source, string format, params object[] args)
 402                         where T : ITraceable
 403                 {
 404                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Verbose, DefaultTraceEventID, format, args);
 405                 }
 406
 407                 public static void TraceVerbose<T>(this T source, int id, string format, params object[] args)
 408                         where T : ITraceable
 409                 {
 410                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Verbose, id, format, args);
 411                 }
 412
 413                 public static void TraceVerbose(Type sourceType, string message)
 414                 {
 415                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 416
 417                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 418                         if (f.ShouldTrace(TraceEventType.Verbose))
 419                         {
 420                                 f.TraceEvent(TraceEventType.Verbose, DefaultTraceEventID, message);
 421                         }
 422                 }
 423
 424                 public static void TraceVerbose(Type sourceType, int id, string message)
 425                 {
 426                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 427
 428                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 429                         if (f.ShouldTrace(TraceEventType.Verbose))
 430                         {
 431                                 f.TraceEvent(TraceEventType.Verbose, id, message);
 432                         }
 433                 }
 434
 435                 public static void TraceVerbose(Type sourceType, string format, params object[] args)
 436                 {
 437                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 438
 439                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 440                         if (f.ShouldTrace(TraceEventType.Verbose))
 441                         {
 442                                 f.TraceEvent(TraceEventType.Verbose, DefaultTraceEventID, format, args);
 443                         }
 444                 }
 445
 446                 public static void TraceVerbose(Type sourceType, int id, string format, params object[] args)
 447                 {
 448                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 449
 450                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 451                         if (f.ShouldTrace(TraceEventType.Verbose))
 452                         {
 453                                 f.TraceEvent(TraceEventType.Verbose, id, format, args);
 454                         }
 455                 }
 456
 457                 public static void TraceWarning<T>(this T source, string message)
 458                         where T : ITraceable
 459                 {
 460                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Warning, DefaultTraceEventID, message);
 461                 }
 462
 463                 public static void TraceWarning<T>(this T source, int id, string message)
 464                         where T : ITraceable
 465                 {
 466                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Warning, id, message);
 467                 }
 468
 469                 public static void TraceWarning<T>(this T source, string format, params object[] args)
 470                         where T : ITraceable
 471                 {
 472                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Warning, DefaultTraceEventID, format, args);
 473                 }
 474
 475                 public static void TraceWarning<T>(this T source, int id, string format, params object[] args)
 476                         where T : ITraceable
 477                 {
 478                         TraceAdapter<T>.Filter.TraceEvent(TraceEventType.Warning, id, format, args);
 479                 }
 480
 481                 public static void TraceWarning(Type sourceType, string message)
 482                 {
 483                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 484
 485                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 486                         if (f.ShouldTrace(TraceEventType.Warning))
 487                         {
 488                                 f.TraceEvent(TraceEventType.Warning, DefaultTraceEventID, message);
 489                         }
 490                 }
 491
 492                 public static void TraceWarning(Type sourceType, int id, string message)
 493                 {
 494                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 495
 496                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 497                         if (f.ShouldTrace(TraceEventType.Warning))
 498                         {
 499                                 f.TraceEvent(TraceEventType.Warning, id, message);
 500                         }
 501                 }
 502
 503                 public static void TraceWarning(Type sourceType, string format, params object[] args)
 504                 {
 505                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 506
 507                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 508                         if (f.ShouldTrace(TraceEventType.Warning))
 509                         {
 510                                 f.TraceEvent(TraceEventType.Warning, DefaultTraceEventID, format, args);
 511                         }
 512                 }
 513
 514                 public static void TraceWarning(Type sourceType, int id, string format, params object[] args)
 515                 {
 516                         if (sourceType == null) throw new ArgumentNullException("sourceType");
 517
 518                         ITraceSourceFilter f = AcquireSourceFilter(sourceType);
 519                         if (f.ShouldTrace(TraceEventType.Warning))
 520                         {
 521                                 f.TraceEvent(TraceEventType.Warning, id, format, args);
 522                         }
 523                 }
 524
 525                 internal static ITraceSourceFilter AcquireSourceFilter(Type t)
 526                 {
 527                         if (t == null) throw new ArgumentNullException("t");
 528
 529                         ITraceSourceFilter result;
 530                         string key = String.Intern(t.Namespace);
 531
 532                         lock (__lock)
 533                         {
 534                                 if (!__filters.TryGetValue(key, out result))
 535                                 {
 536                                         Stack<string> keys = new Stack<string>();
 537                                         TraceSource src = new TraceSource(key);
 538                                         keys.Push(key);
 539                                         while (src.Switch.DisplayName == key)
 540                                         {
 541                                                 int i = key.LastIndexOf('.');
 542                                                 if (i <= 0) break;
 543                                                 key = String.Intern(key.Substring(0, i));
 544                                                 if (__filters.TryGetValue(key, out result))
 545                                                 {
 546                                                         src = result.Source;
 547                                                         break;
 548                                                 }
 549                                                 keys.Push(key);
 550                                                 src = new TraceSource(key);
 551                                         }
 552                                         switch (src.Switch.Level)
 553                                         {
 554                                                 case SourceLevels.ActivityTracing:
 555                                                 case SourceLevels.All:
 556                                                         result = new AllSourceFilter(src);
 557                                                         break;
 558                                                 case SourceLevels.Critical:
 559                                                         result = new CriticalSourceFilter(src);
 560                                                         break;
 561                                                 case SourceLevels.Error:
 562                                                         result = new ErrorSourceFilter(src);
 563                                                         break;
 564                                                 case SourceLevels.Information:
 565                                                         result = new InformationSourceFilter(src);
 566                                                         break;
 567                                                 case SourceLevels.Verbose:
 568                                                         result = new VerboseSourceFilter(src);
 569                                                         break;
 570                                                 case SourceLevels.Warning:
 571                                                         result = new WarningSourceFilter(src);
 572                                                         break;
 573                                                 case SourceLevels.Off:
 574                                                 default:
 575                                                         result = new NullSourceFilter(src);
 576                                                         break;
 577                                         }
 578                                         foreach (string kk in keys)
 579                                         {
 580                                                 __filters.Add(kk, result);
 581                                         }
 582                                 }
 583                         }
 584                         return result;
 585                 }
 586
 587                 #endregion Methods
 588
 589                 #region Nested Types
 590
 591                 internal static class TraceAdapter<T>
 592                         where T : ITraceable
 593                 {
 594                         #region Fields
 595
 596                         private static ITraceSourceFilter __filter;
 597
 598                         #endregion Fields
 599
 600                         #region Constructors
 601
 602                         static TraceAdapter()
 603                         {
 604                                 __filter = Diagnostics.AcquireSourceFilter(typeof(T));
 605                         }
 606
 607                         #endregion Constructors
 608
 609                         #region Properties
 610
 611                         internal static ITraceSourceFilter Filter
 612                         {
 613                                 get { return __filter; }
 614                         }
 615
 616                         #endregion Properties
 617                 }
 618
 619                 #endregion Nested Types
 620         }
 621 }