With SerilogWeb.Owin discontinued, is there an "official" integration? - asp.net-web-api

Question

I came across the discontinuation notice of the SerilogWeb.Owin package, and in reading the GitHub issue there was discussion about "redirecting folks somewhere" given the ~5K+ downloads of the package.
But I haven't been able to figure out where I'm being redirected to!
So where should I be looking for a "Serilog-blessed" integration for using Serilog with an (OWIN) self-hosted Web API?

Answer 1

The package boils down to the following, which I derived from the issues in [the repo](https://github.com/serilog-web/owin/blob/master/src/SerilogWeb.Owin/Owin/LoggerFactory.cs
):
Adding a RequestId to allow traces to be correlated
using (Serilog.Context.LogContext.PushProperty("RequestId", Guid.NewGuid().ToString("N"))
Plug in a logger redirector:
app.SetLoggerFactory(new SerilogOwinFactory());
Copy in the impl (this works with WebApi 5.2.4, Katana 4.0, Serilog 2.6) and incorporates learnings from another question about efficiently forwarding events without the writing treating the message as a template, and ensuring the Exception is included a first class element of the message in order that it can be formatted and/or demystyfied corrrectly:
And the good news is that, when you reach ASP.NET Core, there will be a fully maintained package with a deeper integration waiting for you, with a one-liner hookin ;)
// From https://github.com/serilog-web/owin/blob/master/src/SerilogWeb.Owin/Owin/LoggerFactory.cs
// Copyright 2015 SerilogWeb, Serilog Contributors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using System.Diagnostics;
using System.Linq;
using Microsoft.Owin.Logging;
using Serilog;
using Serilog.Core;
using Serilog.Events;
using ILogger = Serilog.ILogger;
namespace SerilogWeb.Owin
{
/// <summary>
/// Implementation of Microsoft.Owin.Logger.ILoggerFactory.
/// </summary>
public class SerilogOwinFactory : ILoggerFactory
{
readonly Func<ILogger> _getLogger;
readonly Func<TraceEventType, LogEventLevel> _getLogEventLevel;
/// <summary>
/// Create a logger factory.
/// </summary>
/// <param name="logger">The logger; if not provided the global <see cref="Serilog.Log.Logger"/> will be used.</param>
/// <param name="getLogEventLevel"></param>
public SerilogOwinFactory(ILogger logger = null, Func<TraceEventType, LogEventLevel> getLogEventLevel = null)
{
_getLogger = logger == null ? (Func<ILogger>)(() => Log.Logger) : (() => logger);
_getLogEventLevel = getLogEventLevel ?? ToLogEventLevel;
}
/// <summary>
/// Creates a new ILogger instance of the given name.
/// </summary>
/// <param name="name">The logger context name.</param>
/// <returns>A logger instance.</returns>
public Microsoft.Owin.Logging.ILogger Create(string name)
{
return new Logger(_getLogger().ForContext(Constants.SourceContextPropertyName, name), _getLogEventLevel);
}
static LogEventLevel ToLogEventLevel(TraceEventType traceEventType)
{
switch (traceEventType)
{
case TraceEventType.Critical:
return LogEventLevel.Fatal;
case TraceEventType.Error:
return LogEventLevel.Error;
case TraceEventType.Warning:
return LogEventLevel.Warning;
case TraceEventType.Information:
return LogEventLevel.Information;
case TraceEventType.Verbose:
return LogEventLevel.Verbose;
case TraceEventType.Start:
return LogEventLevel.Debug;
case TraceEventType.Stop:
return LogEventLevel.Debug;
case TraceEventType.Suspend:
return LogEventLevel.Debug;
case TraceEventType.Resume:
return LogEventLevel.Debug;
case TraceEventType.Transfer:
return LogEventLevel.Debug;
default:
throw new ArgumentOutOfRangeException("traceEventType");
}
}
class Logger : Microsoft.Owin.Logging.ILogger
{
readonly ILogger _logger;
readonly Func<TraceEventType, LogEventLevel> _getLogEventLevel;
static readonly Exception _exceptionPlaceHolder = new Exception("(Exception enclosed)");
internal Logger(ILogger logger, Func<TraceEventType, LogEventLevel> getLogEventLevel)
{
_logger = logger;
_getLogEventLevel = getLogEventLevel;
}
public bool WriteCore(TraceEventType eventType, int eventId, object state, Exception exception, Func<object, Exception, string> formatter)
{
var level = _getLogEventLevel(eventType);
// According to docs http://katanaproject.codeplex.com/SourceControl/latest#src/Microsoft.Owin/Logging/ILogger.cs
// "To check IsEnabled call WriteCore with only TraceEventType and check the return value, no event will be written."
if (state == null)
return _logger.IsEnabled(level);
if (!_logger.IsEnabled(level))
return false;
var formattedMessage = formatter(state, null); // Omit exception as we're including it in the LogEvent
var template = new Serilog.Events.MessageTemplate(new[] { new Serilog.Parsing.TextToken(formattedMessage) });
var logEvent = new Serilog.Events.LogEvent(DateTimeOffset.Now, level, exception, template, Enumerable.Empty<Serilog.Events.LogEventProperty>());
_logger.ForContext("eventId", eventId).Write(logEvent);
return true;
}
}
}
}