1. NLog란 무엇인가요? 🤔

NLog는 닷넷(.NET) 플랫폼을 위한 유연한 로깅 라이브러리예요. 2006년에 처음 등장한 이후로 계속 발전해왔고, 2025년 현재는 닷넷 생태계에서 가장 인기 있는 로깅 솔루션 중 하나로 자리잡았어요.

요즘 개발 트렌드는 관찰 가능성(Observability)을 중요시하는데, NLog는 이런 트렌드에 완벽하게 부합하는 도구예요. 특히 마이크로서비스 아키텍처나 클라우드 환경에서 시스템 모니터링과 디버깅을 위한 필수 도구로 자리잡았죠!

위 다이어그램을 보면 NLog가 어떻게 작동하는지 한눈에 이해할 수 있죠? 애플리케이션에서 발생한 로그를 NLog 로거가 받아서 다양한 대상으로 전달하는 구조예요. 진짜 쩐다... 이런 구조 덕분에 로깅 코드는 그대로 두고 설정만 바꿔서 로그 대상을 변경할 수 있어요! 👍

2. NLog 설치 및 기본 설정하기 🛠️

자, 이제 본격적으로 NLog를 설치하고 설정해볼까요? 2025년 기준으로 최신 방법을 알려드릴게요!

2.1 NuGet 패키지 설치

먼저 NuGet 패키지 매니저를 통해 NLog를 설치해야 해요. Visual Studio에서는 다음과 같이 할 수 있어요:

Install-Package NLog
Install-Package NLog.Config

dotnet add package NLog
dotnet add package NLog.Config

ASP.NET Core 애플리케이션을 개발 중이라면, 통합 패키지도 설치하는 것이 좋아요:

Install-Package NLog.Web.AspNetCore

2.2 기본 설정 파일 만들기

NLog를 사용하려면 설정 파일이 필요해요. NLog.config 파일을 프로젝트 루트에 생성하고 다음과 같이 기본 설정을 추가해볼게요:

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      autoReload="true"
      throwExceptions="false">

  <targets>
    <!-- 파일에 로그 기록 -->
    <target xsi:type="File" name="file" fileName="${basedir}/logs/${shortdate}.log"
            layout="${longdate} | ${level:uppercase=true} | ${logger} | ${message} ${exception:format=tostring}" />
            
    <!-- 콘솔에 로그 출력 -->
    <target xsi:type="Console" name="console"
            layout="${longdate} | ${level:uppercase=true} | ${logger} | ${message}" />
  </targets>

  <rules>
    <!-- 모든 로그를 파일과 콘솔에 기록 -->
    <logger name="*" minlevel="Info" writeTo="file,console" />
  </rules>
</nlog>

이 설정은 Info 레벨 이상의 모든 로그를 파일과 콘솔에 기록하도록 지정하고 있어요. 로그 파일은 프로젝트 폴더 내의 logs 디렉토리에 날짜별로 생성돼요.

2.3 코드에서 NLog 초기화하기

이제 C# 코드에서 NLog를 사용해볼까요? 먼저 Program.cs나 Startup.cs에서 NLog를 초기화해야 해요:

using NLog;
using NLog.Web;
using System;

// ASP.NET Core가 아닌 일반 콘솔 앱에서는
var logger = LogManager.GetCurrentClassLogger();

try
{
    logger.Info("애플리케이션 시작 중...");
    // 애플리케이션 코드
}
catch (Exception ex)
{
    logger.Error(ex, "애플리케이션 실행 중 예외 발생");
    throw;
}
finally
{
    LogManager.Shutdown(); // 종료 시 로그 버퍼 정리
}

ASP.NET Core 애플리케이션에서는 다음과 같이 설정할 수 있어요:

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        })
        .ConfigureLogging(logging =>
        {
            logging.ClearProviders();
            logging.SetMinimumLevel(Microsoft.Extensions.Logging.LogLevel.Trace);
        })
        .UseNLog(); // NLog 통합

이렇게 하면 ASP.NET Core의 내장 로깅 시스템과 NLog가 통합되어 작동해요. 진짜 편하죠? ㅋㅋㅋ

// appsettings.json에 NLog 설정 추가
{
  "NLog": {
    "targets": {
      "file": {
        "type": "File",
        "fileName": "${basedir}/logs/${shortdate}.log"
      }
    },
    "rules": [
      {
        "logger": "*",
        "minLevel": "Info",
        "writeTo": "file"
      }
    ]
  }
}

3. 다양한 로그 레벨 활용하기 📊

NLog는 다양한 로그 레벨을 제공해서 상황에 맞게 로그를 남길 수 있어요. 로그 레벨은 로그의 중요도를 나타내며, 이를 통해 필터링하거나 다른 방식으로 처리할 수 있죠.

3.1 NLog의 로그 레벨

NLog는 다음과 같은 로그 레벨을 제공해요 (심각도 높은 순):

1. Fatal: 애플리케이션이 즉시 종료되어야 하는 심각한 오류
2. Error: 오류가 발생했지만 애플리케이션은 계속 실행될 수 있음
3. Warn: 잠재적인 문제 상황이나 예상치 못한 동작
4. Info: 일반적인 애플리케이션 진행 상황
5. Debug: 개발 중에 유용한 상세 정보
6. Trace: 가장 상세한 정보, 모든 것을 로깅

3.2 로그 레벨 사용 예시

실제 코드에서는 다음과 같이 다양한 로그 레벨을 사용할 수 있어요:

using NLog;
using System;

public class UserService
{
    private static readonly Logger Logger = LogManager.GetCurrentClassLogger();
    
    public bool Login(string username, string password)
    {
        Logger.Trace("Login 메소드 호출됨: 사용자 = {0}", username);
        
        try
        {
            Logger.Debug("사용자 인증 시작: {0}", username);
            
            // 데이터베이스 조회 등의 로직
            bool isValidUser = ValidateUser(username, password);
            
            if (isValidUser)
            {
                Logger.Info("사용자 로그인 성공: {0}", username);
                return true;
            }
            else
            {
                Logger.Warn("잘못된 로그인 시도: {0}", username);
                return false;
            }
        }
        catch (Exception ex)
        {
            Logger.Error(ex, "로그인 처리 중 오류 발생: {0}", username);
            return false;
        }
    }
    
    private bool ValidateUser(string username, string password)
    {
        // 실제 인증 로직
        if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
        {
            Logger.Fatal("치명적 보안 오류: 빈 사용자 이름 또는 비밀번호로 로그인 시도");
            throw new SecurityException("보안 위반");
        }
        
        // 데이터베이스 조회 등
        return true; // 예시 코드
    }
}

3.3 조건부 로깅으로 성능 최적화

로그를 많이 남기면 애플리케이션 성능에 영향을 줄 수 있어요. NLog는 조건부 로깅을 통해 이 문제를 해결할 수 있어요:

// 기존 방식 (문자열 연결 연산이 항상 발생)
logger.Debug("사용자 데이터: " + userData.ToString());

// 개선된 방식 (Debug 레벨이 활성화된 경우에만 문자열 연결)
logger.Debug("사용자 데이터: {0}", userData);

// 더 복잡한 로깅의 경우 람다 사용
if (logger.IsDebugEnabled)
{
    logger.Debug(() => "복잡한 계산 결과: " + ExpensiveOperation());
}

2025년 현재 구조화된 로깅(Structured Logging)이 대세인데, NLog도 이를 완벽하게 지원해요:

// 구조화된 로깅 예시
logger.Info("주문 처리됨: {OrderId} 금액: {Amount}원 고객: {Customer}", 
    order.Id, order.Amount, order.CustomerName);

이렇게 하면 로그 분석 도구에서 필드별로 쉽게 검색하고 필터링할 수 있어요. 진짜 꿀팁이죠? 🍯

4. 로그 대상(Targets) 설정하기 🎯

NLog의 가장 강력한 기능 중 하나는 다양한 로그 대상(Targets)을 지원한다는 점이에요. 로그를 파일, 콘솔, 데이터베이스 등 여러 곳에 동시에 기록할 수 있죠!

4.1 주요 로그 대상 유형

<target xsi:type="File" name="file" 
        fileName="${basedir}/logs/${shortdate}.log" 
        archiveFileName="${basedir}/archives/${shortdate}.{#}.log"
        archiveEvery="Day"
        archiveNumbering="Sequence"
        maxArchiveFiles="7" />

<target xsi:type="Console" name="console"
        layout="${longdate}|${level:uppercase=true}|${message}" />

<target xsi:type="Database" name="db">
    <connectionString>Server=myServerAddress;Database=myDatabase;User Id=myUsername;Password=myPassword;</connectionString>
    <commandText>
        INSERT INTO Logs (Time, Level, Logger, Message, Exception)
        VALUES (@Time, @Level, @Logger, @Message, @Exception);
    </commandText>
    <parameter name="@Time" layout="${longdate}" />
    <parameter name="@Level" layout="${level}" />
    <parameter name="@Logger" layout="${logger}" />
    <parameter name="@Message" layout="${message}" />
    <parameter name="@Exception" layout="${exception:tostring}" />
</target>

<target xsi:type="Mail" name="mail"
        subject="애플리케이션 오류 발생!"
        to="admin@example.com"
        from="noreply@example.com"
        smtpServer="smtp.example.com"
        smtpPort="25"
        layout="${longdate} - ${level:uppercase=true}${newline}${message}${newline}${exception:format=tostring}" />

4.2 고급 로그 대상 설정

2025년에는 클라우드 기반 로깅이 대세인데, NLog도 이를 지원해요:

// NuGet 패키지 설치
Install-Package NLog.Extensions.AzureApplicationInsights

// NLog.config 설정
<extensions>
  <add assembly="NLog.Extensions.AzureApplicationInsights" />
</extensions>

<targets>
  <target xsi:type="ApplicationInsightsTarget" name="aiTarget"
          instrumentationKey="your-instrumentation-key" />
</targets>

// NuGet 패키지 설치
Install-Package NLog.AWS.Logger

// NLog.config 설정
<extensions>
  <add assembly="NLog.AWS.Logger" />
</extensions>

<targets>
  <target xsi:type="AWSTarget" name="aws"
          logGroup="MyAppLogs"
          region="us-east-1" />
</targets>

2025년에는 로그 분석 플랫폼과의 통합이 중요해졌어요. Elasticsearch, Splunk, Grafana Loki 등과 통합하면 로그 데이터를 시각화하고 분석하기 쉬워져요:

// Elasticsearch 통합 예시
Install-Package NLog.Targets.ElasticSearch

<extensions>
  <add assembly="NLog.Targets.ElasticSearch" />
</extensions>

<targets>
  <target xsi:type="ElasticSearch" name="elastic"
          uri="http://localhost:9200/"
          index="nlog-${date:format=yyyy.MM.dd}" />
</targets>

4.3 비동기 로깅으로 성능 향상

로깅이 애플리케이션 성능에 영향을 주지 않도록 비동기 래퍼를 사용할 수 있어요:

<targets async="true">
  <target xsi:type="File" name="file" fileName="logs.txt" />
</targets>

// 또는 더 세밀한 제어를 위해
<targets>
  <target xsi:type="AsyncWrapper" name="asyncFile" queueLimit="5000" overflowAction="Discard">
    <target xsi:type="File" name="file" fileName="logs.txt" />
  </target>
</targets>

이렇게 하면 로깅 작업이 별도의 스레드에서 처리되어 메인 애플리케이션 흐름이 차단되지 않아요. 진짜 개이득! ㅋㅋㅋ

5. 로그 레이아웃 커스터마이징 ✨

로그의 형식을 어떻게 구성할지 정의하는 레이아웃은 로그 분석과 가독성에 매우 중요해요. NLog는 다양한 레이아웃 옵션을 제공하죠!

5.1 기본 레이아웃 렌더러

NLog에서 자주 사용되는 레이아웃 렌더러들이에요:

5.2 레이아웃 예시

다양한 레이아웃 예시를 살펴볼까요?

// 기본 텍스트 형식
<target name="file" xsi:type="File" fileName="logs.txt"
        layout="${longdate} | ${level:uppercase=true} | ${logger} | ${message} ${exception:format=tostring}" />

// JSON 형식 (로그 분석 도구와 통합하기 좋음)
<target name="jsonFile" xsi:type="File" fileName="logs.json">
  <layout xsi:type="JsonLayout">
    <attribute name="time" layout="${longdate}" />
    <attribute name="level" layout="${level:uppercase=true}" />
    <attribute name="logger" layout="${logger}" />
    <attribute name="message" layout="${message}" />
    <attribute name="exception" layout="${exception:format=tostring}" encode="false" />
    <attribute name="url" layout="${aspnet-request-url}" />
    <attribute name="user" layout="${aspnet-user-identity}" />
  </layout>
</target>

// CSV 형식 (Excel로 분석하기 좋음)
<target name="csv" xsi:type="File" fileName="logs.csv">
  <layout xsi:type="CsvLayout">
    <column name="Time" layout="${longdate}" />
    <column name="Level" layout="${level}" />
    <column name="Logger" layout="${logger}" />
    <column name="Message" layout="${message}" />
    <column name="Exception" layout="${exception:format=tostring}" />
  </layout>
</target>

5.3 색상 지정 (콘솔 로그용)

콘솔 로그에 색상을 추가하면 가독성이 훨씬 좋아져요:

<target xsi:type="ColoredConsole" name="coloredConsole"
        layout="${longdate} | ${level:uppercase=true} | ${logger} | ${message}">
  <highlight-word foregroundColor="DarkGreen" text="SUCCESS" />
  <highlight-row condition="level == LogLevel.Debug" foregroundColor="Gray" />
  <highlight-row condition="level == LogLevel.Info" foregroundColor="White" />
  <highlight-row condition="level == LogLevel.Warn" foregroundColor="Yellow" />
  <highlight-row condition="level == LogLevel.Error" foregroundColor="Red" />
  <highlight-row condition="level == LogLevel.Fatal" foregroundColor="Red" backgroundColor="White" />
</target>

5.4 구조화된 로깅을 위한 레이아웃

2025년에는 구조화된 로깅이 표준이 되었어요. NLog에서는 다음과 같이 설정할 수 있어요:

// C# 코드에서 구조화된 로깅 사용
logger.Info("주문 생성: {OrderId} 고객: {Customer} 금액: {Amount}원", 
    order.Id, order.CustomerName, order.TotalAmount);

// NLog.config에서 JSON 레이아웃 설정
<target xsi:type="File" name="jsonFile" fileName="logs.json">
  <layout xsi:type="JsonLayout" includeAllProperties="true">
    <attribute name="time" layout="${longdate}" />
    <attribute name="level" layout="${level}" />
    <attribute name="logger" layout="${logger}" />
    <attribute name="message" layout="${message}" />
  </layout>
</target>

이렇게 하면 로그가 다음과 같이 JSON 형식으로 저장돼요:

{
  "time": "2025-03-19 14:35:23.4567",
  "level": "Info",
  "logger": "OrderService",
  "message": "주문 생성: ORD-12345 고객: 홍길동 금액: 35000원",
  "OrderId": "ORD-12345",
  "Customer": "홍길동",
  "Amount": 35000
}

이런 구조화된 로그는 Elasticsearch, Splunk 같은 로그 분석 도구에서 필드별로 검색하고 집계하기 쉬워요. 진짜 개발자 인생이 편해지는 거죠! ㅋㅋㅋ

// 미들웨어에서 상관 ID 생성
app.Use(async (context, next) => {
    var correlationId = context.Request.Headers["X-Correlation-ID"].FirstOrDefault() 
                     ?? Guid.NewGuid().ToString();
    
    // NLog에 상관 ID 추가
    LogManager.Configuration.Variables["correlationId"] = correlationId;
    
    await next();
});

// NLog.config에서 사용
<layout xsi:type="JsonLayout">
  <attribute name="correlationId" layout="${var:correlationId}" />
  // 다른 속성들...
</layout>

6. 실전 예제: 웹 애플리케이션에서 NLog 활용하기 🌐

이론은 충분히 배웠으니 이제 실전 예제를 통해 NLog를 웹 애플리케이션에 적용해볼게요! ASP.NET Core 웹 애플리케이션을 예로 들어볼게요.

6.1 ASP.NET Core 웹 애플리케이션에 NLog 통합하기

먼저 필요한 패키지를 설치해요:

Install-Package NLog.Web.AspNetCore
Install-Package Microsoft.Extensions.Logging

Program.cs 파일에서 NLog를 설정해요:

using NLog;
using NLog.Web;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

var logger = LogManager.Setup()
                      .LoadConfigurationFromAppSettings()
                      .GetCurrentClassLogger();
try
{
    logger.Info("애플리케이션 초기화 중...");
    
    var builder = WebApplication.CreateBuilder(args);
    
    // NLog 설정
    builder.Logging.ClearProviders();
    builder.Host.UseNLog();
    
    // 서비스 등록
    builder.Services.AddControllers();
    builder.Services.AddEndpointsApiExplorer();
    builder.Services.AddSwaggerGen();
    
    var app = builder.Build();
    
    // 미들웨어 설정
    if (app.Environment.IsDevelopment())
    {
        app.UseSwagger();
        app.UseSwaggerUI();
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
        app.UseHsts();
    }
    
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthorization();
    
    app.MapControllers();
    
    // 요청 로깅 미들웨어 추가
    app.Use(async (context, next) =>
    {
        var logger = context.RequestServices.GetRequiredService<ILogger<Program>>();
        logger.LogInformation("요청 시작: {Method} {Path}", context.Request.Method, context.Request.Path);
        
        var stopwatch = System.Diagnostics.Stopwatch.StartNew();
        await next();
        stopwatch.Stop();
        
        logger.LogInformation("요청 완료: {Method} {Path} - 상태 코드: {StatusCode}, 소요 시간: {ElapsedMs}ms",
            context.Request.Method, context.Request.Path, context.Response.StatusCode, stopwatch.ElapsedMilliseconds);
    });
    
    app.Run();
}
catch (Exception ex)
{
    logger.Error(ex, "애플리케이션 시작 중 예외 발생");
    throw;
}
finally
{
    LogManager.Shutdown();
}

appsettings.json에 NLog 설정을 추가해요:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "NLog": {
    "throwConfigExceptions": true,
    "targets": {
      "async": true,
      "logfile": {
        "type": "File",
        "fileName": "${basedir}/logs/${shortdate}.log",
        "layout": "${longdate}|${event-properties:item=EventId:whenEmpty=0}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}"
      },
      "logconsole": {
        "type": "Console"
      }
    },
    "rules": [
      {
        "logger": "*",
        "minLevel": "Info",
        "writeTo": "logconsole"
      },
      {
        "logger": "*",
        "minLevel": "Debug",
        "writeTo": "logfile"
      }
    ]
  }
}

6.2 컨트롤러에서 로깅 사용하기

이제 컨트롤러에서 로깅을 사용해볼게요:

using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;

namespace WebApp.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class UsersController : ControllerBase
    {
        private readonly ILogger<UsersController> _logger;
        private readonly IUserService _userService;
        
        public UsersController(ILogger<UsersController> logger, IUserService userService)
        {
            _logger = logger;
            _userService = userService;
        }
        
        [HttpGet]
        public async Task<IActionResult> GetUsers()
        {
            _logger.LogInformation("사용자 목록 조회 요청 받음");
            
            try
            {
                var users = await _userService.GetAllUsersAsync();
                _logger.LogDebug("조회된 사용자 수: {Count}", users.Count);
                
                return Ok(users);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "사용자 목록 조회 중 오류 발생");
                return StatusCode(500, "내부 서버 오류가 발생했습니다.");
            }
        }
        
        [HttpGet("{id}")]
        public async Task<IActionResult> GetUser(int id)
        {
            _logger.LogInformation("사용자 상세 조회 요청: ID = {UserId}", id);
            
            try
            {
                var user = await _userService.GetUserByIdAsync(id);
                
                if (user == null)
                {
                    _logger.LogWarning("사용자를 찾을 수 없음: ID = {UserId}", id);
                    return NotFound();
                }
                
                _logger.LogDebug("사용자 조회 성공: {User}", user);
                return Ok(user);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "사용자 조회 중 오류 발생: ID = {UserId}", id);
                return StatusCode(500, "내부 서버 오류가 발생했습니다.");
            }
        }
        
        [HttpPost]
        public async Task<IActionResult> CreateUser(UserCreateDto model)
        {
            _logger.LogInformation("사용자 생성 요청: {UserName}", model.UserName);
            
            try
            {
                // 입력 유효성 검사
                if (string.IsNullOrEmpty(model.UserName))
                {
                    _logger.LogWarning("잘못된 사용자 생성 요청: 사용자 이름이 비어 있음");
                    return BadRequest("사용자 이름은 필수입니다.");
                }
                
                var newUser = await _userService.CreateUserAsync(model);
                
                _logger.LogInformation("사용자 생성 성공: ID = {UserId}, 이름 = {UserName}", 
                    newUser.Id, newUser.UserName);
                
                return CreatedAtAction(nameof(GetUser), new { id = newUser.Id }, newUser);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "사용자 생성 중 오류 발생: {UserName}", model.UserName);
                return StatusCode(500, "내부 서버 오류가 발생했습니다.");
            }
        }
    }
}

6.3 전역 예외 처리와 로깅

애플리케이션 전체에서 발생하는 예외를 처리하고 로깅하는 미들웨어를 추가해볼게요:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using System.Net;
using System.Text.Json;

public static class ExceptionMiddlewareExtensions
{
    public static void ConfigureExceptionHandler(this IApplicationBuilder app, ILogger logger)
    {
        app.UseExceptionHandler(appError =>
        {
            appError.Run(async context =>
            {
                context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
                context.Response.ContentType = "application/json";
                
                var contextFeature = context.Features.Get<IExceptionHandlerFeature>();
                if (contextFeature != null)
                {
                    logger.LogError(contextFeature.Error, "처리되지 않은 예외 발생");
                    
                    await context.Response.WriteAsync(JsonSerializer.Serialize(new
                    {
                        StatusCode = context.Response.StatusCode,
                        Message = "내부 서버 오류가 발생했습니다."
                    }));
                }
            });
        });
    }
}

Program.cs에서 이 미들웨어를 등록해요:

// Program.cs에 추가
var logger = app.Services.GetRequiredService<ILogger<Program>>();
app.ConfigureExceptionHandler(logger);

이렇게 구조화된 로그를 통해 애플리케이션의 동작을 쉽게 추적할 수 있어요. 재능넷 같은 웹 서비스를 운영한다면 이런 로그 시스템은 필수적이죠! 사용자 활동, 성능 문제, 오류 등을 실시간으로 모니터링할 수 있으니까요. 👀

7. 로그 필터링과 라우팅 🔍

모든 로그를 다 기록하면 로그 파일이 너무 커지고 중요한 정보를 찾기 어려워져요. NLog는 로그를 필터링하고 다양한 대상으로 라우팅하는 강력한 기능을 제공해요!

7.1 로거 이름으로 필터링

네임스페이스나 클래스 이름을 기준으로 로그를 필터링할 수 있어요:

<rules>
  <!-- 데이터 액세스 관련 로그는 상세하게 기록 -->
  <logger name="WebApp.Data.*" minlevel="Debug" writeTo="dataLogFile" />
  
  <!-- 컨트롤러 로그는 Info 레벨부터 기록 -->
  <logger name="WebApp.Controllers.*" minlevel="Info" writeTo="apiLogFile" />
  
  <!-- 외부 라이브러리 로그는 경고 이상만 기록 -->
  <logger name="Microsoft.*" minlevel="Warn" writeTo="externalLogFile" />
  
  <!-- 나머지 모든 로그 -->
  <logger name="*" minlevel="Info" writeTo="defaultLogFile" />
</rules>

7.2 로그 레벨에 따른 라우팅

로그 레벨에 따라 다른 대상으로 로그를 보낼 수 있어요:

<rules>
  <!-- 오류와 치명적 오류는 이메일로 알림 -->
  <logger name="*" minlevel="Error" writeTo="email" />
  
  <!-- 경고 이상은 데이터베이스에 저장 -->
  <logger name="*" minlevel="Warn" writeTo="database" />
  
  <!-- 모든 로그는 파일에 저장 -->
  <logger name="*" minlevel="Debug" writeTo="file" />
  
  <!-- 개발 환경에서만 콘솔에 출력 -->
  <logger name="*" minlevel="Trace" writeTo="console" final="true">
    <filters>
      <when condition="${environment:ASPNETCORE_ENVIRONMENT}=='Development'" action="Log" />
      <when condition="true" action="Ignore" />
    </filters>
  </logger>
</rules>

7.3 조건부 로깅

특정 조건에 따라 로그를 필터링할 수 있어요:

<rules>
  <!-- 특정 IP에서 오는 요청만 상세 로깅 -->
  <logger name="*" minlevel="Trace" writeTo="detailedLog">
    <filters>
      <when condition="${aspnet-request-ip}=='192.168.1.1'" action="Log" />
      <when condition="true" action="Ignore" />
    </filters>
  </logger>
  
  <!-- 로그인 실패 관련 로그만 별도 파일에 기록 -->
  <logger name="*" writeTo="securityLog">
    <filters>
      <when condition="${message:contains=로그인 실패}" action="Log" />
      <when condition="true" action="Ignore" />
    </filters>
  </logger>
</rules>

7.4 로그 필터링을 위한 사용자 정의 필터

더 복잡한 필터링이 필요하다면 사용자 정의 필터를 만들 수 있어요:

// CustomLogFilter.cs
using NLog;
using NLog.Filters;

public class CustomLogFilter : Filter
{
    public CustomLogFilter()
    {
        // 필터 초기화
    }
    
    protected override FilterResult Check(LogEventInfo logEvent)
    {
        // 특정 조건에 따라 로그 필터링
        if (logEvent.Message?.Contains("민감한 정보") == true)
        {
            // 민감한 정보가 포함된 로그는 필터링
            return FilterResult.Ignore;
        }
        
        // 사용자 ID가 특정 값인 경우만 로깅
        if (logEvent.Properties.ContainsKey("UserId") && 
            logEvent.Properties["UserId"].ToString() == "admin")
        {
            return FilterResult.Log;
        }
        
        // 기본적으로는 다음 필터로 넘김
        return FilterResult.Neutral;
    }
}

// NLog.config에 등록
<extensions>
  <add assembly="MyApplication" />
</extensions>

<rules>
  <logger name="*" minlevel="Debug" writeTo="file">
    <filters>
      <filter type="MyApplication.CustomLogFilter" />
    </filters>
  </logger>
</rules>

// MaskingLayoutRenderer.cs
[LayoutRenderer("mask")]
public class MaskingLayoutRenderer : LayoutRenderer
{
    [DefaultParameter]
    public string Text { get; set; }
    
    protected override void Append(StringBuilder builder, LogEventInfo logEvent)
    {
        if (string.IsNullOrEmpty(Text))
            return;
            
        // 이메일 마스킹 (예: a***@example.com)
        if (Text.Contains("@"))
        {
            var parts = Text.Split('@');
            if (parts.Length == 2)
            {
                var username = parts[0];
                var domain = parts[1];
                var maskedUsername = username.Length > 1 
                    ? username[0] + new string('*', username.Length - 1) 
                    : username;
                builder.Append($"{maskedUsername}@{domain}");
                return;
            }
        }
        
        // 전화번호 마스킹 (예: 010-****-5678)
        if (Text.Contains("-"))
        {
            var parts = Text.Split('-');
            if (parts.Length == 3)
            {
                builder.Append($"{parts[0]}-****-{parts[2]}");
                return;
            }
        }
        
        // 기본 마스킹 (앞 2자리만 표시)
        if (Text.Length > 2)
        {
            builder.Append(Text.Substring(0, 2) + new string('*', Text.Length - 2));
        }
        else
        {
            builder.Append(Text);
        }
    }
}

7.5 환경별 로그 설정

개발, 테스트, 프로덕션 환경에 따라 다른 로그 설정을 사용하는 것이 좋아요:

<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  
  <variable name="environment" value="${environment:ASPNETCORE_ENVIRONMENT:default=Production}" />
  
  <targets>
    <!-- 개발 환경용 타겟 -->
    <target xsi:type="Console" name="devConsole" 
            layout="${longdate}|${level:uppercase=true}|${logger}|${message}" />
    
    <!-- 테스트 환경용 타겟 -->
    <target xsi:type="File" name="testFile" 
            fileName="${basedir}/logs/test-${shortdate}.log" />
    
    <!-- 프로덕션 환경용 타겟 -->
    <target xsi:type="File" name="prodFile" 
            fileName="${basedir}/logs/prod-${shortdate}.log"
            archiveFileName="${basedir}/archives/prod-{#}.zip"
            archiveEvery="Day"
            maxArchiveFiles="30"
            archiveNumbering="Date"
            archiveDateFormat="yyyy-MM-dd"
            enableArchiveFileCompression="true" />
    
    <target xsi:type="Database" name="prodDb">
      <!-- 데이터베이스 설정 -->
    </target>
  </targets>
  
  <rules>
    <!-- 개발 환경 -->
    <logger name="*" minlevel="Trace" writeTo="devConsole">
      <filters>
        <when condition="${var:environment}=='Development'" action="Log" />
        <when condition="true" action="Ignore" />
      </filters>
    </logger>
    
    <!-- 테스트 환경 -->
    <logger name="*" minlevel="Debug" writeTo="testFile">
      <filters>
        <when condition="${var:environment}=='Staging'" action="Log" />
        <when condition="true" action="Ignore" />
      </filters>
    </logger>
    
    <!-- 프로덕션 환경 -->
    <logger name="*" minlevel="Info" writeTo="prodFile,prodDb">
      <filters>
        <when condition="${var:environment}=='Production'" action="Log" />
        <when condition="true" action="Ignore" />
      </filters>
    </logger>
  </rules>
</nlog>

이렇게 환경별로 로그 설정을 분리하면 각 환경에 맞는 로깅 전략을 적용할 수 있어요. 개발 중에는 상세한 로그를, 프로덕션에서는 중요한 로그만 남기는 식으로요! 👍

8. 성능 최적화 팁 ⚡

로깅은 애플리케이션 성능에 영향을 줄 수 있어요. 특히 고성능 애플리케이션에서는 로깅으로 인한 오버헤드를 최소화하는 것이 중요하죠. 여기 몇 가지 성능 최적화 팁을 소개할게요!

8.1 비동기 로깅 사용

NLog의 비동기 래퍼를 사용하면 로깅 작업이 메인 스레드를 차단하지 않아요:

<targets async="true">
  <target xsi:type="File" name="file" fileName="logs.txt" />
</targets>

// 또는 더 세밀한 제어를 위해
<targets>
  <target xsi:type="AsyncWrapper" 
          name="asyncFile" 
          queueLimit="10000" 
          timeToSleepBetweenBatches="50"
          batchSize="100"
          overflowAction="Discard">
    <target xsi:type="File" name="file" fileName="logs.txt" />
  </target>
</targets>

비동기 래퍼의 주요 설정 옵션을 살펴볼게요:

1. queueLimit: 큐에 저장할 수 있는 최대 로그 이벤트 수
2. batchSize: 한 번에 처리할 로그 이벤트 수
3. timeToSleepBetweenBatches: 배치 처리 사이의 대기 시간(밀리초)
4. overflowAction: 큐가 가득 찼을 때 동작 (Discard, Block, Grow)

8.2 조건부 로깅으로 문자열 연산 최소화

로그 메시지 생성 시 문자열 연결 연산이 많이 발생하면 성능에 영향을 줄 수 있어요. 조건부 로깅을 사용해 이를 최소화할 수 있어요:

// 비효율적인 방식 (항상 문자열 연산 발생)
logger.Debug("사용자 정보: " + user.ToString() + ", 주문 내역: " + orders.ToString());

// 효율적인 방식 (Debug 레벨이 활성화된 경우에만 문자열 연산)
logger.Debug("사용자 정보: {0}, 주문 내역: {1}", user, orders);

// 더 복잡한 경우 IsEnabled 체크
if (logger.IsDebugEnabled)
{
    var detailedInfo = GenerateDetailedInfo(); // 비용이 많이 드는 연산
    logger.Debug("상세 정보: {0}", detailedInfo);
}

8.3 버퍼링과 배치 처리

로그를 버퍼링하고 배치로 처리하면 I/O 작업을 줄일 수 있어요:

<target xsi:type="BufferingWrapper" 
        name="bufferedFile"
        bufferSize="100"
        flushTimeout="5000">
  <target xsi:type="File" name="file" fileName="logs.txt" />
</target>

이 설정은 최대 100개의 로그 이벤트를 버퍼에 저장하고, 버퍼가 가득 차거나 5초가 지나면 파일에 기록해요.

8.4 로그 파일 압축 및 보관

로그 파일이 커지면 디스크 공간을 많이 차지하고 I/O 성능에 영향을 줄 수 있어요. 자동 압축 및 보관 설정을 활용해보세요:

<target xsi:type="File" 
        name="file" 
        fileName="${basedir}/logs/current.log"
        archiveFileName="${basedir}/archives/{#}.zip"
        archiveEvery="Day"
        archiveNumbering="Date"
        archiveDateFormat="yyyy-MM-dd"
        maxArchiveFiles="30"
        enableArchiveFileCompression="true" />

이 설정은 매일 로그 파일을 압축하여 보관하고, 30일이 지난 로그는 자동으로 삭제해요.

8.5 로그 레벨 최적화

프로덕션 환경에서는 필요한 로그만 남기도록 로그 레벨을 조정하세요:

<rules>
  <!-- 개발 환경 -->
  <logger name="*" minlevel="Debug" writeTo="allLogs">
    <filters>
      <when condition="${var:environment}=='Development'" action="Log" />
      <when condition="true" action="Ignore" />
    </filters>
  </logger>
  
  <!-- 프로덕션 환경 -->
  <logger name="*" minlevel="Info" writeTo="productionLogs" />
  
  <!-- 성능 관련 로그는 별도 파일에 기록 -->
  <logger name="*.Performance" minlevel="Debug" writeTo="performanceLogs" />
</rules>

8.6 로그 레이아웃 최적화

복잡한 레이아웃은 로그 생성 시간을 증가시킬 수 있어요. 필요한 정보만 포함하도록 레이아웃을 최적화하세요:

// 비효율적인 레이아웃 (너무 많은 정보)
<target xsi:type="File" name="file" fileName="logs.txt"
        layout="${longdate} | ${level:uppercase=true} | ${logger} | ${message} | ${exception:format=tostring} | ${stacktrace} | ${callsite} | ${all-event-properties} | ${environment-user} | ${processid} | ${threadid} | ${windows-identity}" />

// 최적화된 레이아웃 (필요한 정보만)
<target xsi:type="File" name="file" fileName="logs.txt"
        layout="${longdate} | ${level:uppercase=true} | ${logger:shortName=true} | ${message} ${exception:format=tostring}" />

2025년에는 JSON 형식의 구조화된 로깅이 표준이 되었는데, 이 경우에도 필요한 필드만 포함하도록 최적화하세요:

<target xsi:type="File" name="jsonFile" fileName="logs.json">
  <layout xsi:type="JsonLayout" includeAllProperties="false">
    <attribute name="time" layout="${longdate}" />
    <attribute name="level" layout="${level}" />
    <attribute name="logger" layout="${logger:shortName=true}" />
    <attribute name="message" layout="${message}" />
    <attribute name="exception" layout="${exception:format=tostring}" encode="false" />
  </layout>
</target>

이렇게 성능을 최적화하면 로깅으로 인한 애플리케이션 성능 저하를 최소화할 수 있어요. 특히 재능넷 같은 트래픽이 많은 웹 서비스에서는 로깅 성능 최적화가 매우 중요하죠! 👍

9. NLog vs 다른 로깅 프레임워크 🥊

닷넷 생태계에는 NLog 외에도 여러 로깅 프레임워크가 있어요. 각각의 장단점을 비교해볼게요!

9.1 NLog vs Serilog

Serilog는 2025년 현재 NLog와 함께 가장 인기 있는 로깅 프레임워크 중 하나예요:

Serilog 코드 예시:

// Serilog 설정 예시
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .WriteTo.Console()
    .WriteTo.File("logs/myapp.txt", rollingInterval: RollingInterval.Day)
    .CreateLogger();

// 로깅 예시
Log.Information("사용자 {UserId}가 {Amount}원 결제함", user.Id, payment.Amount);

9.2 NLog vs log4net

log4net은 오래된 로깅 프레임워크로, 여전히 많은 레거시 프로젝트에서 사용되고 있어요:

log4net 코드 예시:

// log4net 설정 예시
<log4net>
  <appender name="FileAppender" type="log4net.Appender.FileAppender">
    <file value="logs/myapp.log" />
    <layout type="log4net.Layout.PatternLayout">
      <conversionPattern value="%date [%thread] %-5level %logger - %message%newline" />
    </layout>
  </appender>
  <root>
    <level value="INFO" />
    <appender-ref ref="FileAppender" />
  </root>
</log4net>

// 로깅 예시
private static readonly ILog log = LogManager.GetLogger(typeof(Program));
log.Info("애플리케이션 시작");

9.3 NLog vs Microsoft.Extensions.Logging

Microsoft.Extensions.Logging(MEL)은 ASP.NET Core의 기본 로깅 인프라예요:

Microsoft.Extensions.Logging 코드 예시:

// MEL 설정 예시
public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureLogging(logging =>
        {
            logging.ClearProviders();
            logging.AddConsole();
            logging.AddDebug();
            logging.AddEventLog();
        })
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        });

// 로깅 예시
public class HomeController : Controller
{
    private readonly ILogger<HomeController> _logger;

    public HomeController(ILogger<HomeController> logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        _logger.LogInformation("홈 페이지 접속");
        return View();
    }
}

// NuGet 패키지 설치
Install-Package NLog.Web.AspNetCore

// Program.cs에서 설정
public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
        })
        .ConfigureLogging(logging =>
        {
            logging.ClearProviders();
            logging.SetMinimumLevel(LogLevel.Trace);
        })
        .UseNLog(); // NLog 통합

이렇게 각 로깅 프레임워크의 장단점을 비교해봤는데요, 프로젝트의 요구사항과 팀의 선호도에 따라 적절한 로깅 프레임워크를 선택하는 것이 중요해요. 재능넷 같은 대규모 웹 서비스라면 NLog나 Serilog 같은 강력한 로깅 프레임워크를 사용하는 것이 좋겠죠? 😉

10. 마무리 및 추가 자료 🎁

지금까지 NLog를 활용한 로깅 구현에 대해 자세히 알아봤어요. 로깅은 애플리케이션 개발에서 정말 중요한 부분이며, 잘 구현된 로깅 시스템은 개발, 디버깅, 모니터링 과정에서 큰 도움이 돼요!

10.1 주요 내용 요약

10.2 NLog 활용 모범 사례

10.3 추가 학습 자료

NLog에 대해 더 자세히 알아보고 싶다면 다음 자료들을 참고해보세요:

10.4 마치며

로깅은 단순히 오류를 추적하는 것을 넘어 애플리케이션의 동작을 이해하고, 성능을 최적화하며, 사용자 경험을 개선하는 데 큰 도움이 돼요. NLog를 활용하면 이러한 로깅 작업을 효율적이고 유연하게 구현할 수 있어요.

재능넷 같은 웹 서비스를 개발하고 운영하는 과정에서도 로깅은 필수적인 요소예요. 사용자 활동을 추적하고, 오류를 빠르게 감지하며, 성능 병목을 식별하는 데 로깅 데이터가 큰 도움이 될 거예요.

이 글이 여러분의 C# 개발 여정에 도움이 되었길 바라요! 로깅의 세계는 생각보다 깊고 넓지만, 한 번 마스터하면 개발 생산성과 애플리케이션 품질을 크게 향상시킬 수 있어요. 😊

혹시 더 궁금한 점이 있거나 추가 정보가 필요하다면, 재능넷의 지식인의 숲에서 다양한 개발 관련 정보를 찾아보세요! 개발자들의 재능 공유와 지식 교류가 활발한 재능넷에서 더 많은 정보를 얻을 수 있을 거예요.

행복한 코딩 되세요! 🚀