如何在Azure函数的业务逻辑库中获取当前HTTP请求信息

这个问题核心是要在独立的业务逻辑库中安全获取Azure Functions的HTTP请求上下文，同时尽量避免业务代码和Azure平台强耦合，我给你几个落地性强的方案，从优雅解耦到快速实现都覆盖了：

这种方式通过定义抽象接口隔离Azure平台细节，让业务逻辑库只依赖抽象，完全不用关心运行环境。

步骤1：定义请求上下文抽象接口 #

在业务逻辑库中定义一个包含所需信息的接口，不要引用任何Azure相关的类型：

public interface IRequestContext
{
    string ClientIpAddress { get; }
    IDictionary<string, string> RequestHeaders { get; }
}

步骤2：在Azure函数项目中实现接口 #

专门写一个适配Azure Functions的实现类，从HttpRequest中提取需要的信息：

public class AzureFunctionRequestContext : IRequestContext
{
    public string ClientIpAddress { get; }
    public IDictionary<string, string> RequestHeaders { get; }

    public AzureFunctionRequestContext(HttpRequest req)
    {
        // 处理客户端IP：优先取X-Forwarded-For（如果有代理/APIM），否则取直接连接IP
        ClientIpAddress = GetClientIp(req);
        
        // 提取请求头，同时过滤敏感信息（比如Authorization、Cookie）
        RequestHeaders = ExtractSafeHeaders(req);
    }

    private string GetClientIp(HttpRequest req)
    {
        if (req.Headers.TryGetValue("X-Forwarded-For", out var forwardedFor))
        {
            // X-Forwarded-For格式可能是 "IP1, IP2, ..."，取第一个真实客户端IP
            return forwardedFor.ToString().Split(',').FirstOrDefault()?.Trim() ?? "Unknown";
        }
        return req.HttpContext.Connection.RemoteIpAddress?.ToString() ?? "Unknown";
    }

    private IDictionary<string, string> ExtractSafeHeaders(HttpRequest req)
    {
        var sensitiveHeaders = new HashSet<string> { "Authorization", "Cookie", "Set-Cookie" };
        return req.Headers
            .Where(h => !sensitiveHeaders.Contains(h.Key, StringComparer.OrdinalIgnoreCase))
            .ToDictionary(h => h.Key, h => string.Join(";", h.Value));
    }
}

步骤3：配置依赖注入 #

在Azure函数的Startup类中注册接口和实现，确保每个请求都能拿到对应的上下文：

public class Startup : FunctionsStartup
{
    public override void Configure(IFunctionsHostBuilder builder)
    {
        // 用Scoped生命周期，每个HTTP请求生成一个上下文实例
        builder.Services.AddScoped<IRequestContext>(sp =>
        {
            var httpRequest = sp.GetRequiredService<HttpRequest>();
            return new AzureFunctionRequestContext(httpRequest);
        });
        
        // 同时注册Logs组件（如果是类而非静态方法）
        builder.Services.AddScoped<Logs>();
    }
}

步骤4：改造业务逻辑和Logs组件 #

让Logs组件通过构造注入获取IRequestContext，业务逻辑如果是实例方法也可以直接注入Logs：

// Logs组件改造
public class Logs
{
    private readonly IRequestContext _requestContext;

    public Logs(IRequestContext requestContext)
    {
        _requestContext = requestContext;
    }

    public void Write(Exception ex)
    {
        // 拼接包含请求上下文的日志内容
        var logContent = $"[ClientIP: {_requestContext.ClientIpAddress}] " +
                        $"[Headers: {string.Join(", ", _requestContext.RequestHeaders.Select(kv => $"{kv.Key}: {kv.Value}"))}] " +
                        $"Exception: {ex.Message}\nStack Trace: {ex.StackTrace}";
        
        // 执行实际日志写入（比如Application Insights、Blob存储等）
    }
}

// 业务逻辑改造（如果是实例类）
public class UserService
{
    private readonly Logs _logs;

    public UserService(Logs logs)
    {
        _logs = logs;
    }

    public void Add(User user)
    {
        try
        {
            // 你的业务逻辑代码
        }
        catch (Exception ex)
        {
            _logs.Write(ex);
        }
    }
}

// 如果业务逻辑是静态方法，也可以直接传递IRequestContext
public static class Users
{
    public static void Add(User user, IRequestContext requestContext)
    {
        try
        {
            // 业务逻辑
        }
        catch (Exception ex)
        {
            var logs = new Logs(requestContext);
            logs.Write(ex);
        }
    }
}

步骤5：在Azure函数中使用 #

直接从依赖注入中获取所需的服务或上下文：

public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
    UserService userService, // 注入业务服务
    ILogger log)
{
    var user = new User { Name = "Test" };
    userService.Add(user);
    return new OkResult();
}

// 如果是静态业务方法
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
    IRequestContext requestContext,
    ILogger log)
{
    var user = new User { Name = "Test" };
    Users.Add(user, requestContext);
    return new OkResult();
}

如果你的业务逻辑比较简单，不想引入依赖注入，可以直接在Azure函数中收集请求信息，封装成简单对象传递给业务逻辑：

步骤1：定义请求信息类 #

public class RequestSnapshot
{
    public string ClientIp { get; set; }
    public IDictionary<string, string> SafeHeaders { get; set; }
}

步骤2：在Azure函数中收集信息并传递 #

public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
    ILogger log)
{
    // 收集请求信息，同样处理IP和敏感头
    var requestSnapshot = new RequestSnapshot
    {
        ClientIp = req.Headers.TryGetValue("X-Forwarded-For", out var forwardedFor) 
            ? forwardedFor.ToString().Split(',').FirstOrDefault()?.Trim() ?? "Unknown"
            : req.HttpContext.Connection.RemoteIpAddress?.ToString() ?? "Unknown",
        SafeHeaders = req.Headers
            .Where(h => !new HashSet<string> { "Authorization", "Cookie" }.Contains(h.Key, StringComparer.OrdinalIgnoreCase))
            .ToDictionary(h => h.Key, h => string.Join(";", h.Value))
    };

    var user = new User { Name = "Test" };
    Users.Add(user, requestSnapshot);
    return new OkResult();
}

步骤3：修改业务逻辑和Logs #

public static class Users
{
    public static void Add(User user, RequestSnapshot snapshot)
    {
        try
        {
            // 业务逻辑
        }
        catch (Exception ex)
        {
            Logs.Write(ex, snapshot);
        }
    }
}

public static class Logs
{
    public static void Write(Exception ex, RequestSnapshot snapshot)
    {
        // 用snapshot里的信息生成日志
    }
}

如果你的Logs组件是基于Azure Functions自带的ILogger，可以直接通过日志范围自动携带请求上下文：

public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req,
    ILogger log)
{
    var clientIp = req.Headers.TryGetValue("X-Forwarded-For", out var forwardedFor) 
        ? forwardedFor.ToString().Split(',').FirstOrDefault()?.Trim() ?? "Unknown"
        : req.HttpContext.Connection.RemoteIpAddress?.ToString() ?? "Unknown";

    var safeHeaders = req.Headers
        .Where(h => !new HashSet<string> { "Authorization", "Cookie" }.Contains(h.Key, StringComparer.OrdinalIgnoreCase))
        .ToDictionary(h => h.Key, h => string.Join(";", h.Value));

    // 创建日志范围，所有在这个范围内的日志都会自动带上这些自定义属性
    using (log.BeginScope(new Dictionary<string, object>
    {
        ["ClientIp"] = clientIp,
        ["RequestHeaders"] = safeHeaders
    }))
    {
        var user = new User { Name = "Test" };
        Users.Add(user);
    }

    return new OkResult();
}

// Logs组件直接使用ILogger
public class Logs
{
    private readonly ILogger<Logs> _logger;

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

    public void Write(Exception ex)
    {
        // 日志会自动包含范围里的ClientIp和RequestHeaders，在Application Insights中可以在自定义维度里看到
        _logger.LogError(ex, "Failed to add user");
    }
}

1. 敏感信息过滤：一定要过滤掉Authorization、Cookie这类敏感头，避免日志泄露用户隐私或凭证。
2. 真实客户端IP获取：如果你的函数前面有APIM、Front Door等代理，必须从X-Forwarded-For头获取真实IP，RemoteIpAddress拿到的会是代理服务器的IP。
3. 避免强耦合：优先选择方案1，让业务逻辑库只依赖抽象，这样以后如果换运行环境（比如换成Web API），只需要实现对应的IRequestContext即可，不用修改业务代码。

内容的提问来源于stack exchange，提问作者NOP-MOV