Standardization of Performance Monitoring, Logging, & Exception Handling via a .NET Runtime Wrapper

Several years ago, I wanted to have my own performance monitoring solution, so I could monitor all enterprise applications. Few enterprises implement this core cross-cutting application task across the enterprise in the same way. By the phrases “core” and “cross-cutting” I mean a feature or functionality set that touches all application development; it’s not specific to a single application. I think some functionality that is repeated across the enterprise should be done the same standard way. A common issue for teams building applications within a single department is often departments do their own thing, even calling the same business entity different names. They rarely consult with the established Enterprise Architectural framework, if one even exist. It’s no surprise that they often have different solutions for core processes like performance monitoring, logging, and exception handling. Seemingly, each application, each application layer, and even sometimes different method calls within the same application, often handle cross-cutting functionality differently. Such applications reflect a lack of architectural knowledge, a lack of architectural planning time, and/or, more likely, a deadline that mandates the development team to just "get it done ASAP". I began to research having a common way to monitor application performance across the enterprise. Ideally, I wanted a simple solution that I could use for all enterprise needs. My first thought was an attribute based solution that I could apply to a method that would create a log entry when the method started and when it ended. This would allow me to identify bottlenecks in the execution of my application, at least for individual method calls, but not for sequential groups of method calls. Creating an attribute that would create a performance log entry when the method started was easy, but the later was impossible (to my knowledge), unless you modified the IL in a Post-Build event, which isn’t ideal. And, after doing more research, I decided that reflection was not the best way to accomplish my needs, since the operation of reflection alone would skew my performance results. Also, I would prefer to not perform reflection in a production environment. So, my idea of creating an attribute based solution to accomplish my goals was not acceptable to me. In this article, I will propose an enterprise level solution to address standardizing exception handling, performance monitoring, and logging. It is implemented in a class called UnitOfWork. It can be used across an entire enterprise and/or application. While this wrapper is called UnitOfWork, do not confuse this with the database concept of a unit of work. This class has nothing to do with a database transaction, however, it would be easy to incorporate such functionality into this class. I will be approaching this solution from a C#.NET point of view; as such, all the code I discuss will be in C# and .NET Core. I won’t discuss this code line by line, so if you don’t know C# or understand lambda expressions, you probably should stop reading now. I will cover a few of the more interesting parts of the code only, I will not cover every single line of code. I acknowledge in advance that this is merely a way to accomplish the goals I have outlined above, and I make no presumption of saying it’s the best way or the only way. Every solution has its own set of issues, including this one. Other technologies do exist the address the same issues I am addressing. I have created this to provide maximum flexibility for any organization that may wish to use it. For instance, if an organization would rather log information (exceptions, logs, performance statistics) to a database, they only need to implement the ILogger interface I have defined to do so, and change their dependency injection configuration to use their own custom logger class. This class supports multiple loggers. I have included a few basic ones as examples. Everything (variables, properties, etc) used is optional and comes with default values. Further still, the entire UnitOfWork class and dependency classes are included in the source code, so feel free to modify it to satisfy your organization’s need. It is not copyrighted, and I only hope others find it as useful as I have. For my solution, I decided a generic wrapper class that doesn’t suffer the performance issues of reflection, but does solve the issues, was my best bet. I could easily pass a lambda expression, or an array of lambda expressions, to my wrapper class, and it could create a log entry, then run the lambda expression(s), then log the duration of execution. This gives me control over the granularity of logging. Also, I have the source code that I can modify to suit any needs I may have in the future. Another perk to this solution is it’s free. ;) It should be noted that the IN and OUT types are the same for all the lambda expressions being run in a single UnitOfWork class instance; however, that doesn’t mean that the IN or OUT couldn’t be a tuple of multiple types, or even an list of tuples of types. Another wonderful thing about lambda expressions is that all the objects that are visible when they are defined are also available inside of the expression itself. For example, if I create a database connection before I instantiate an UnitOfWork class, then the lambda expression(s) that I define for the UnitOfWork has access to that database connection object. The returned OUT type is the result of the last run lambda expression, but I have created two publicly accessible list properties that saves/clones the result of both inputs and outputs after each lambda expression’s execution, if more than one lambda expression is defined. These are serialized using the Json Serializer after each lambda expression’s execution and added to the list; however, only public member values are saved. I clone these IN and OUT values for pretty obvious reasons; think about ByRef and ByVal. I started to use the binary serializer to get all member values, but that requires the type to have the Serializable attribute to be applied to it. As I built this wrapper I started to realize that it could encapsulate much more than just my performance monitoring needs. I realized my class could solve another common problem (a common problem, but rarely commonly solved across the enterprises) — exception handling. In most applications, the user is protected from the details of an exception thrown, since that information is pretty useless to the application user, but has very important relevance for the developer and his team that needs to debug the issue. This wrapper logs the much needed detailed exception information for developer debugging, while shielding that information from the application user. As an example, if a SQL exception is thrown, perhaps the only thing the application’s user really needs to see is "The requested operation failed; please try again." Basically, the user friendly message is meaningless to the developer, but shields the user from the devil in the details. The developer wants to see the details behind what happened. But, sometimes, I don’t want to handle exceptions in certain methods; sometimes I want the exception to bubble up to the caller. So, I added both the exception handling code, as well as the flexibility to specify if you want the class to rethrow the exception to the caller. If you elect to have this wrapper not handle the exception inside of its own TryCatch, then an exception will bubble up like normal. Also, my choice of a class versus a struct or a static method, or even an extension method, was made for several reasons. The benefit of allowing parameters to be set via a class initializer was one reason. While I have provided several constructors for common object creation needs, I often find a class initializer beneficial for class creation to set properties not available in the constructor. Also, to me, class initializers are far easier to read. As far as the overhead of a class being created, I don’t see that as an issue. I considered making this a struct, to avoid garbage collection, but if an instance of UnitOfWork were to be passed as a parameter to other classes, then that could have a very serious impact on the memory stack, as a copy would be made and passed, rather than a reference passed. Garbage collection in .NET is generally faster than the C++ delete method. Class creation is negligible in .NET. It only becomes issue when you create classes inside of a loop with large (millions) quantities of elements. This class uses no unmanaged or disposable resources, but if the methods you pass to it do, then you should dispose of those responsibly yourself. If you modify this class to use unmanaged or disposable resources, you may need to utilize using statements and possibly implement IDisposable and the appropriate methods. 3 attributes of interest that are somewhat new to .NET. CallerMemberName, CallerLineNumber, and CallerFilePath attributes are applied to the Execute method. These are defined in the System.Runtime.CompilerServices namespace, and their names pretty much define what they do. I will let you look those up for yourself; they simply provide more information to the person that reviews any exception logging issues. I have a property called UnitOfWorkName. You should give this a meaningful name because it will appear in the logs. Remember, this name applies to all of the lambda expressions you pass into this class. The last constructor is the only one that is of importance, as it does the work. The last parameter to this constructor is meaningless, so just ignore it. It is only there to provide an unique signature. This is protected scope for obvious reasons, so anyone who inherits from this class can access it. The scope/visibility of everything in this class has a reason. For instance, the Function property get is private, and, again, for obvious reasons, to prevent bypassing the whole purpose of this wrapper class. Ok, next is the exception details. The ExceptionDispatchInfo class defines a few static methods that allow for the capture of an exception’s state. It is part of the System.Runtime.ExceptionServices namespace. I remember the first time I had to debug an error that was throwing an exception but the call stack was gone (what a joy to discover). If you want to have your exceptions bubble up to your calling location (this is the default behavior), then you will get the original exception including its saved call stack. I have defined several explicit cast operators should you wish to cast this class to a different, more useful type. The meaning of these cast operators is clear. If you read and understand this class, you should understand those easily. I have put comments throughout the code where I thought it would be useful. I have put an extension method that does part of what this wrapper in the code as well, should you be interested in looking at it. Also, I typed up a quick ExecuteTransaction extension method for you to look at if you want the functionality of a database unit of work (included in the code). I prefer to handle database transactions in stored procedures myself, but feel free to use this. Simply select all the code below and paste it into a single C# cs file. I think any experienced C# developer should be able to read the code and understand it. For that reason, I have not discussed the code itself. It is below for your perusal. UnitOfWork is a flexible, free, and modifiable generic class wrapper that solves many core enterprise issues. In this case, performance monitoring, logging, and exception handling were addressed. I can think of other things that could be added to this to be of benefit to specific enterprises. Authentication and authorization, to name two, but I leave this to implement for yourself, since that is pretty different for each enterprise. About the author... Lee McGraw has worked in the technology industry for over 30 years, first developing on an Apple II. He has served as Enterprise Developer and Architect for entities such as AIG, Ford, Coke, USAA, US Department of Defense and Energy, and many banks. Thanks to Peter Vogel for proof reading this. ; .Collections.Generic; . ; .IO; .Runtime.CompilerServices; .Runtime.ExceptionServices; .Runtime.Serialization.Json; .Text; static .Console; static .String;

namespace CoreConsoleAppLee { MyReferenceClass { string { ; ; } } Program { string InstanceMethod( num) { "Inside of Instance Method. " + num.ToString(); } static string StaticMethod( num) { "Inside of Static Method. " + num.ToString(); }

static Main(string[] args) { var myProgram = Program(); var uow = UnitOfWork (r => { "Inside of Statement Lambda. " + r.ToString(); }) { UnitOfWorkName = "Demostration of Unit of Work usage." }; uow.AddFunction(r => "Inside of Expression Lambda." + r.ToString()); uow.AddFunction(r => StaticMethod(r)); uow.AddFunction(r => myProgram.InstanceMethod(r)); var input = ; uow. ( );

Console.WriteLine("\nInputs to calls..."); uow.Inputs. (r => { Console.WriteLine(r.ToString()); }); Console.WriteLine("\nOutputs to calls..."); uow.Outputs. (r => { Console.WriteLine(r.ToString()); }); var uow2 = UnitOfWork (r => { r.Name = r.Name.ToUpper(); r; }); uow2.AddFunction(f => { f.Name = f.Name.ToLower(); f; }); var res = uow2. ( MyReferenceClass { = "Daffy Duck" });

Console.WriteLine("\nInputs to calls..."); uow2.Inputs. (r => { Console.WriteLine(r.Name.ToString()); }); Console.WriteLine("\nOutputs to calls..."); uow2.Outputs. (r => { Console.WriteLine(r.Name.ToString()); });

var i = ; } }

/// /// This encapsulates the performance , handling, logging a / a methods. /// be confused the the . It a UnitOfWork, although that support could easily be added. /// The purpose this handle a measurable unit , well a logical endpoint handling. /// /// being passed the ; this necessarily a single , because it could be a collection. /// being returned the ; this necessarily a single , because it could be a collection a tuple many . UnitOfWork { private const string defaultUnitOfWorkName = "UnitOfWork";

#region Members

protected stopWatch { ; ; } protected { ; ; } protected List Loggers { ; ; } = List ();

#endregion Members

#region Properties private string CallerMethodName { ; ; } private CallerLineNumber { ; ; } private string CallerFilePath { ; ; } string UnitOfWorkName { ; ; } = defaultUnitOfWorkName; private string MethodName { ; ; } UseStopwatch { ; ; } = ; UseTryCatch { ; ; } = ; RethrowExceptions { ; ; } = ;

//private below prevent the developer this bypass the operational logic the , thereby negating the intension this completely. List > { private ; ; } = List >(); Func { private ; ; } List Inputs { ; private ; } List Outputs { ; private ; }

#endregion Properties

#region Constructors UnitOfWork( Func , string unitOfWorkName = defaultUnitOfWorkName, useStopwatch = , useTryCatch = , rethrowExceptions = , ILogger logger = ) : this( Func [] { }, unitOfWorkName, useStopwatch, useTryCatch, rethrowExceptions, logger, ) { } UnitOfWork( Func [] , string unitOfWorkName = defaultUnitOfWorkName, useStopwatch = , useTryCatch = , rethrowExceptions = , ILogger logger = , uniqueSignaturePurposesOnly = ) { //the uniqueSignaturePurposesOnly parameter there make this constructor have a signature, can be ignored it used. ( == || .Length == ) { throw ArgumentException("The value of functions can not be null or empty!"); } InitParameters(); InitStopwatch(); InitLoggers(); InitParameters() { = [ ]; AddFunction( ); UnitOfWorkName = unitOfWorkName ?? defaultUnitOfWorkName; // the parameter was , perhaps it was the constructor already, use the MethodName = . .Name; UseStopwatch = useStopwatch; UseTryCatch = useTryCatch; RethrowExceptions = rethrowExceptions; } InitLoggers() { Loggers = List (); Loggers. (logger ?? ConsoleLogger()); (logger != ) { Loggers = Loggers ?? List (); Loggers. (logger); }

} InitStopwatch() { (useStopwatch) { stopWatch = (); stopWatch. (UnitType.UnitOfWork, Stopwatch()); stopWatch. (UnitType. , Stopwatch()); } } }

#endregion Constructor

#region Methods AddFunction(params Func [] ) => .AddRange( ); AddLogger(params ILogger[] loggers) => Loggers.AddRange(loggers); ( , [CallerMemberName] string callerMethodName = "", [CallerLineNumber] callerLineNumber = , [CallerFilePath] string callerFilePath = "" ) { result = ( ); CallerMethodName = callerMethodName; CallerLineNumber = callerLineNumber; CallerFilePath = callerFilePath; ( .Count > ) { Inputs = Inputs ?? List (); Outputs = Outputs ?? List (); } (UseTryCatch) { try { Run(); } catch ( e) { ExceptionDispatchInfo.Capture(e); = e; Loggers. ( => .WriteError($@" An ERROR has occurred! {UnitOfWorkName}-{MethodName}", Concat($@" Caller Info: Method={CallerMethodName} Line={CallerLineNumber} Path={CallerFilePath} ", ((ExceptionManager) ).ToString()) ) ); (RethrowExceptions) ExceptionDispatchInfo.Throw(e); } finally { (UnitType.UnitOfWork); } } { Run(); } result; Run() { (UnitType.UnitOfWork); ?. (f => { = f; MethodName = f. .Name; (); Inputs?. (Clone( )); result = (f != ? f.Invoke( ) : result); Outputs?. (Clone(result)); (); }); (UnitType.UnitOfWork); } } protected virtual (UnitType unitType = UnitType. ) { (!UseStopwatch) ; Loggers. ( => .WriteInfo( generateSource(unitType), generateMessage(unitType, $"Starting at {System.DateTime.Now.ToString()}!") ) ); (stopWatch[unitType].IsRunning) stopWatch[unitType]. (); stopWatch[unitType]. (); } protected virtual (UnitType unitType = UnitType. ) { (!UseStopwatch) ; stopWatch[unitType].Stop(); Loggers. ( => .WriteInfo( generateSource(unitType), generateMessage(unitType, Concat("Ran in ", stopWatch[unitType].ElapsedMilliseconds.ToString(), $"ms. Ending at {System.DateTime.Now.ToString()}!")) ) ); }

private string generateSource(UnitType unitType) { Concat(unitType.ToString(), "|", unitType == UnitType.UnitOfWork ? UnitOfWorkName : MethodName); } private string generateMessage(UnitType unitType, string postFix = "") { Concat("(", unitType == UnitType.UnitOfWork ? UnitOfWorkName : MethodName, ")", postFix); } /// /// a deep the , a serialization . /// NOTE: Private members are cloned this . /// required, but it s the LAST thing we want. /// EventViewerLogger : ILogger { EventViewerLogger() { } virtual WriteInfo(string source, string message) { EventLog.WriteEntry(source, message); } virtual WriteError(string source, string message) { EventLog.WriteEntry(source, message); } }

#endregion EventViewerLogger

#region ConsoleLogger ConsoleLogger : ILogger { ConsoleLogger() { } virtual WriteInfo(string source, string message) { WriteLine(source + "-" + message); } virtual WriteError(string source, string message) { WriteLine(source + "-" + message); } }

#endregion ConsoleLogger

#region ILogger

/// /// implement your own logger, implement this interface. /// interface ILogger { WriteInfo(string source, string message); WriteError(string source, string message); }

#endregion ILogger struct ExceptionManager { private ; private ExceptionManager( ) { this. = ; } override string ToString() { var sb = StringBuilder(); sb.Append("**********\n"); { sb.Append($"Message:{exception.Message}"); sb.Append($"\nSource:{exception.Source}"); sb.Append($"\nTargetSite:{exception.TargetSite}"); sb.Append($"\nStackTrace:{exception.StackTrace}"); sb.Append($"\nHelpLink:{exception.HelpLink}"); = .InnerException; ( != ) sb.Append("\n----------"); } ( != ); sb.Append("\n**********\n"); sb.ToString(); } static explicit (ExceptionManager exceptionManager) { exceptionManager. ; } static explicit ExceptionManager( ) { ExceptionManager( ); } static explicit string(ExceptionManager exceptionManager) { exceptionManager.ToString(); } } } /* * Written by Lee McGraw (in my personal free time), Enterprise Architect/Developer US DoD * Feel free to modify this code to suit your own needs. * An article accompanies this code, titled "Standardization of Performance Monitoring, Logging, and Exception Handling via a .NET Runtime Wrapper" * Google it if you are interested. */ using System using System using System Diagnostics using System using System using System using System using System using System using System public class public Name get set class public int return public int return void new new int return 10 Execute input ForEach ForEach new return return Execute new Name ForEach ForEach 0 summary class timing exception and of method and or group of Do NOT by name of class is NOT database of class is to of work as as for exception summary name Type as input method is not object name Type by method is not object or of types public class IN OUT Dictionary get set Exception exception get set get set new get set int get set get set public get set get set public bool get set true public bool get set true public bool get set true get to using to of execute method of public IN OUT Functions get set new IN OUT public IN OUT Function get set public IN get set public OUT get set public IN OUT function bool true bool true bool true null new IN OUT function true public IN OUT functions bool true bool true bool true null bool true is only to unique and as is not if functions null functions 0 new void Function functions 0 functions if null then set in else Method name Function Method void #if DEBUG new Add new #endif if null new Add void if new Dictionary Add new Add Method new public void IN OUT functions Functions functions public void public OUT Execute IN input int 0 OUT default OUT if Functions 1 new IN new OUT if Exception exception ForEach log log exception if End else return void Start Functions ForEach Function Method Start Add input null input Add End End void Start Method if return ForEach log log if Reset Start void End Method if return ForEach log log return return summary Perform Copy of object using Json as method not using method Serializable attribute is not if 's an object, the class needs a parameterless constructor. /// /// The type of object being copied. /// The object instance to copy. /// The copied object. private T Clone (T source) { var result = default(T); var jsonString = ""; using (var stream = new MemoryStream()) { var serializer = new DataContractJsonSerializer(typeof(T)); serializer.WriteObject(stream, source); byte[] json = stream.ToArray(); jsonString = Encoding.UTF8.GetString(json, 0, json.Length); } using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString))) { var serializer = new DataContractJsonSerializer(typeof(T)); result = (T)serializer.ReadObject(stream); } return result; }

#endregion Methods

#region Cast Operators

public static explicit operator Func (UnitOfWork unitOfWork) => unitOfWork.Function; public static explicit operator List >(UnitOfWork unitOfWork) => unitOfWork.Functions; public static explicit operator UnitOfWork (List > functions) => new UnitOfWork (functions.ToArray()); public static explicit operator UnitOfWork (Func function) => new UnitOfWork (function);

#endregion Cast Operators }

public enum UnitType { Method, UnitOfWork } public static class Extender { public static void ExecuteTransaction(this System.Data.IDbConnection connection, params System.Data.IDbCommand[] commands) { using (connection) { if (connection.State != System.Data.ConnectionState.Open) connection.Open(); using (var transaction = connection.BeginTransaction()) { try { foreach (var command in commands) { command.ExecuteNonQuery(); } transaction.Commit(); } catch { transaction.Rollback(); } } } } public static OUT Execute (this IN toThat, bool useTryCatch = true, params Func [] doThis) { var result = default(OUT); if (toThat == null && doThis == null) return result; if (useTryCatch) { try { foreach (var function in doThis) { result = function(toThat); } } catch { throw; } } else { foreach (var function in doThis) { result = function(toThat); } } return result; }

public static void With (this T toThat, Action doThis) where T : class => doThis?.Invoke(toThat); public static OUT With (this IN toThat, Func doThis) => doThis.Invoke(toThat); }

#region EventViewerLogger

/// /// You need the .NET Core compatibility nuget package, if you use this in .NET Core, to write to the EventViewer. /// Search NuGet for package named Microsoft.Windows.Compatibility. /// This could have been accomplished via a delegate too, but that would add overhead, /// and if this used enterprise wide, that' summary public class public public void public void public class public public void public void summary To summary public void void public Exception exception Exception exception exception exception public new do exception exception if exception null while exception null return public operator Exception return exception public operator Exception exception return new exception public operator return