Microsoft.Extensions.Logging.Log4Net.AspNetCore - GitLite

KO | EN

gitlite — search

#javascript #hacktoberfest #react #ai #typescript #golang #android #nodejs #macos #java #awesome #cli #security #ios

Microsoft.Extensions.Logging.Log4Net.AspNetCore

(★ 262)

Allows to configure Log4net as Microsoft Extensions Logging handler on any ASP.NET Core application. Original code proposal by @anuraj --> https://dotnetthoughts.net/how-to-use-log4net-with-aspnetcore-for-logging/

파일 탐색기

최종 버전 다운로드 (.zip)

- - deploy.yml
  - pr.yml
- main.yml
- sdk.yaml
- CONFIG.md
- ModifyingLoggingBehaviour.md
- - copilot-instructions.md
- - ILog4NetLoggingEventFactory.cs
  - ILog4NetLogLevelTranslator.cs
  - Log4NetExtensions.cs
  - Log4NetLogger.cs
  - Log4NetLoggingEventFactory.cs
  - Log4NetLogLevelTranslator.cs
  - Log4NetProvider.cs
  - Log4NetProviderOptions.cs
  - Microsoft.Extensions.Logging.Log4Net.AspNetCore.csproj
- Microsoft.Extensions.Logging.Log4net.sln
- - CompatibilityTests.cs
  - log4net.config
  - Log4NetExtensionsTests.cs
  - Log4NetLoggerTests.cs
  - Log4NetProviderOptionsTests.cs
  - Log4NetProviderTests.cs
  - Unit.Tests.csproj
.gitattributes
.gitignore
coverage.cmd
LICENSE
README.md

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/huorswords/Microsoft.Extensions.Logging.Log4Net.AspNetCore

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd Microsoft.Extensions.Logging.Log4Net.AspNetCore

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. .NET

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
.NET SDK dotnet 명령어를 쓰기 위한 SDK입니다.

cd src/Microsoft.Extensions.Logging.Log4Net.AspNetCore

이 프로젝트의 관련 파일이 하위 폴더 안에 있어서, 먼저 그 폴더로 이동합니다.

dotnet restore

프로젝트에 필요한 패키지를 내려받습니다.

dotnet run

프로젝트를 빌드하고 바로 실행합니다.

✅ dotnet run 실행 후 터미널에 나타나는 안내 메시지나 주소를 확인하세요.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Microsoft.Extensions.Logging.Log4Net.AspNetCore

Allows to configure Log4net as Microsoft Extensions Logging handler on any ASP.NET Core application.

Thanks to [@anuraj](https://github.com/anuraj) for this [original blog post](https://dotnetthoughts.net/how-to-use-log4net-with-aspnetcore-for-logging/).

[![Release Build](https://github.com/huorswords/Microsoft.Extensions.Logging.Log4Net.AspNetCore/actions/workflows/deploy.yml/badge.svg)](https://github.com/huorswords/Microsoft.Extensions.Logging.Log4Net.AspNetCore/actions/workflows/deploy.yml)
[![NuGet](https://img.shields.io/nuget/dt/Microsoft.Extensions.Logging.Log4net.AspNetCore.svg)](https://www.nuget.org/packages/Microsoft.Extensions.Logging.Log4Net.AspNetCore/)

## GitHub Actions deployment

The documented release workflow runs in GitHub Actions. It builds, tests, and packs the NuGet package on `main` and on manual dispatch.

If you want assembly signing to remain enabled in GitHub, add these repository secrets:

* `SIGNING_SNK_BASE64` for `Microsoft.Extensions.Logging.Log4Net.AspNetCoreKey.snk`
* `SIGNING_PFX_BASE64` for the companion private certificate file, if you want to keep that asset available privately
* `SIGNING_PUBLIC_KEY_BASE64` for the public key file, if you want to keep that asset available privately

The workflow restores any configured signing assets into the runner at runtime; none of the signing files need to be committed to the repository.

## Example of use

* Install the package or reference the project into your asp.net core application.

* Add the `AddLog4Net()` call into your `Configure` method of the `Startup` class.

```csharp
using Microsoft.Extensions.Logging;

public class Startup
{
    //...

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        //...

loggerFactory.AddLog4Net(); // << Add this line
        app.UseMvc();

//...
    }
}
```
* For dotnet 6.0 and later add `builder.Logging.AddLog4Net();` call in your `Program.cs` file.

* Add a `log4net.config` file with the content:

```xml
<?xml version="1.0" encoding="utf-8" ?>
<log4net>
  <appender name="DebugAppender" type="log4net.Appender.DebugAppender" >
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
    </layout>
  </appender>
  <root>
    <level value="ALL"/>
    <appender-ref ref="DebugAppender" />
  </root>
</log4net>
```

You can found more configuration examples on [configuration documentation](https://github.com/huorswords/Microsoft.Extensions.Logging.Log4Net.AspNetCore/blob/develop/doc/CONFIG.md).

## FAQ

### Using BeginScope

> Associated issues #45

From version 2.2.7, this nuget allow to use the `BeginScope` method from `Log4NetLogger`.

```csharp
var dictionary = new Dictionary<string, string>() { { "test", "SCOPED_VALUE" } };
using (var scope = logger.BeginScope(dictionary))
{
    logger.LogCritical(message);
}
```

The `BeginScope` method allow any object, but only some of types are handled in an special way. Those types are:

* `string`
* `IEnumerable<KeyValuePair<string, string>>`
* `IEnumerable<KeyValuePair<string, object>>`
* `ValueTuple<string, T>` where `T` is `string`, any numeric type or `object`

By default, any other type will be managed as a conventional `object`.

#### How it works

When you use any of the `IEnumerable<KeyValuePair<,>>` allowed types, the collection will be processed and every item from this collection should be introduced to the `LogicalThreadContext` managed by the log4net library using the `Key` as the property name and the `Value` as the value to replace the placeholder on the Pattern Layout defined.

This example shows how the log4net.config pattern layout could include a `%property{}` placeholder that will be matched within the corresponding scoped value from the collection argument.

```xml
<layout type="log4net.Layout.PatternLayout">
    
    <conversionPattern value="%date [%thread] %-5level %logger %ndc - scope=%property{scope} - %property{custom_name} - %message%newline" />
</layout>
```

When you use the `BeginScope` method passing a collection that contains a KeyValuePair within the key `custom_name`, the logged message will contain the `SCOPED_VALUE` text on it.

```csharp
var dictionary = new Dictionary<string, string>() { { "custom_name", "SCOPED_VALUE" } };
using (var scope = logger.BeginScope(dictionary))
{
    logger.LogCritical(message); // SCOPED_VALUE will replace the %property{custom_name} placeholder
}
```

At the other hand, if the argument is not from the given `IEnumerable<KeyValuePair<,>>`, the value will be logged on the default `scope` property.

```csharp
using (var scope = logger.BeginScope("SCOPED_VALUE"))
{
    logger.LogCritical(message); // SCOPED_VALUE will replace the %property{scope} placeholder
}

using (var scope = logger.BeginScope(Guid.NewGuid()))
{
    logger.LogCritical(message); // Guid value will replace the %property{scope} placeholder
}
```

And, when you use two chained `BeginScope` calls...

```csharp
using (var scope = logger.BeginScope("SCOPED_VALUE"))
{
    using (var scope = logger.BeginScope(Guid.NewGuid()))
    {
        logger.LogCritical(message); // SCOPED_VALUE and Guid value (both) will replace the %property{scope} placeholder
    }
}
```

For additional information about how the `LogicalThreadContext` works, please visit the [official documentation](https://logging.apache.org/log4net/release/manual/contexts.html)

### .NET Core 2.0 - Logging debug level messages

> Associated issues #34 & #41

In order to be able to register Debug level messages in any of your configured log4net appenders, you should change the ASP .NET Core 2 configuration when you build your `IWebHost` instance as follows.

```csharp
public static IWebHost BuildWebHost(string[] args) =>
    WebHost.CreateDefaultBuilder(args)
           .UseStartup<Startup>()
           .ConfigureLogging((hostingContext, logging) =>
            {
              // The ILoggingBuilder minimum level determines the
              // the lowest possible level for logging. The log4net
              // level then sets the level that we actually log at.
              logging.AddLog4Net();
              logging.SetMinimumLevel(LogLevel.Debug);
            })
            .Build();
```
### Logging lower than the Information Level

> Associated issues #85

Also note that when trying to allow for levels messages below the Information level for a development build you must make allowances for it in the `appsettings.Development.json` as specified in the [documentation](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/logging/?view=aspnetcore-3.1#configure-logging "Microsoft's Information on Logging providers' Configuration") and illustrated below:
```json
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
	  "...":"..."
    }
  }
}
```

### Modifying logging behaviour
In many cases you can modfiy the logging behaviour of the provider to fit your own needs. See [modifying logging behaviour](https://github.com/huorswords/Microsoft.Extensions.Logging.Log4Net.AspNetCore/blob/develop/doc/ModifyingLoggingBehaviour.md) for more information.

## Special thanks

Thank you very much to all contributors & users by its collaboration, and specially to:

* [@twenzel](https://github.com/twenzel) by his great job on adapting the library to the new logging recomendations for .NET Core 2.
* [@sBoff](https://github.com/sBoff) by the fix of the mutiple calls to XmlConfigurator.Configure issue.
* [@kastwey](https://github.com/kastwey) by the feature to allow to replace values of log4net.config using the *Microsoft.Extensions.Configuration*.
* [@willwolfram18](https://github.com/willwolfram18) by bugfixing `Log4NetScopeFactory` usage when provided in `Log4NetProviderOptions`.
* [@lscorcia](https://github.com/lscorcia) by the fix of incorrect call stack when logging.
* [@JustusGreiberORGADATA](https://github.com/JustusGreiberORGADATA) by the inclusion of a configurable logging event factory, and `IExternalScope` provider implementation.
* [@Radim Holek](https://github.com/rholek) for enabling `ValueTuple` mapping in scopes.