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