psibr / contextually

A dead simple contextual block pattern library that works, even with async/await and threads.

Contextually

Enables contextual information to flow with your code:

using System;
using Contextually;

namespace Sample
{
  class App
  {
    static void Main(string[] args)
    {
      // Setup top level context of the entire app.
      var systemContext = new NameValueCollection
      {
        ["MachineName"] = System.Environment.MachineName
      };
      
      using (Relevant.Info(systemContext))
      {
        // Shows that the context flows even if you start a new thread.
        Task.Run(AppMainLoop).Wait();
      }
      // This is the end of the context scope.
    }
    
    void AppMainLoop()
    {
      Console.WriteLine("Enter your name:");
      var userName = Console.ReadLine();

      var appContext = new NameValueCollection
      {
        ["UserName"] = userName
      };
      
      // Setup a sub-context of relevant information.
      using (Relevant.Info(systemContext))
      {
        while (...)
          DoWork();
      }
      // End of the sub-scope. The "UserName" is not
      // available anymore, but 'MachineName' still is.
    }

    void DoWork()
    {
      try
      {
        ...
      }
      catch (Exception ex)
      {
        // Now you can collect all contextual information
        // from all open scopes and sub-scopes.
        var aggregatedContext = Relevant.Info();
        // This helps with analysis of 'dynamic' data,
        // which is not known at compile time.
        Logger.LogError(ex, aggregatedContext);
      }
    }
  }
}

contextually's Issues

.NET45 Test failing with scoping

Feature Request: Allow custom Relevant instances

Currently, the static AsyncLocal<InfoBlock> is hidden behind static Relevant class. This works for a simple app. Once you want to build a more complex one, where multiple modules can use Contextually in different ways, this would become a problem due to absence of isolation of the contextual data of different modules.

My proposal is to make the Relevant class non-static, and allow custom instances of it. For example, I'm building a logging module that uses Contextually:

static class Log
{
    private static Relevant _relevant = new Relevant();

    public static IDisposable Info(NameValueCollection info)
        => _relevant .Info(info);
}

using (Log.Info(...))
{
  ...
}