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