java 电力日志审计设计

转载

mob64ca140dc73b 2024-12-16 16:24:26

文章标签 java 电力日志审计设计 System Core 客户端 文章分类 Java 后端开发

前言：

　　近日在项目协同开发过程中出现了问题，数据出现了异常；其他人员怀疑项目数据丢失程序存在问题。于是通过排查程序提供的审计日志最终还原了当时操作及原因。

　　可见审计日志在排查、定位问题是相当有用的，那么在.Net Core 如何来实现审计日志呢？

　　接下来一步步来实现效果

一、审计日志定义及作用

　审计日志：　　

维基百科： “审计跟踪（也叫审计日志）是与安全相关的按照时间顺序的记录，记录集或者记录源，它们提供了活动序列的文档证据，这些活动序列可以在任何时间影响一个特定的操作，步骤或其他”

　作用：

　　1、快速定位问题耗时及性能情况

　　2、记录调用时环境信息：如浏览器、参数等

二、.Net Core 中实现审计日志

　那么怎么实现审计日志呢？其实核心思想很简单。包含以下步骤：

获取调用接口方法时相关信息
记录当前接口耗时情况
保存审计日志信息到数据库中

　　那么如何获取调用接口时相关信息呢？.Net Core中可以使用：过滤器、拦截器 实现。　

　　本次示例中将采用过滤器实现审计日志实现功能；主要流程如下

java 电力日志审计设计_System

定义审计日志信息：　　

public class AuditInfo
{
    /// <summary>
    /// 调用参数
    /// </summary>
    public string Parameters { get; set; }
    /// <summary>
    /// 浏览器信息
    /// </summary>
    public string BrowserInfo { get; set; }
    /// <summary>
    /// 客户端信息
    /// </summary>
    public string ClientName { get; set; }
    /// <summary>
    /// 客户端IP地址
    /// </summary>
    public string ClientIpAddress { get; set; }
    /// <summary>
    /// 执行耗时
    /// </summary>
    public int ExecutionDuration { get; set; }
    /// <summary>
    /// 执行时间
    /// </summary>
    public DateTime ExecutionTime { get; set; }
    /// <summary>
    /// 返回内容
    /// </summary>
    public string ReturnValue { get; set; }
    /// <summary>
    /// 异常对象
    /// </summary>
    public Exception Exception { get; set; }
    /// <summary>
    /// 方法名
    /// </summary>
    public string MethodName { get; set; }
    /// <summary>
    /// 服务名
    /// </summary>
    public string ServiceName { get; set; }
    /// <summary>
    /// 调用者信息
    /// </summary>
    public string UserInfo { get; set; }
    /// <summary>
    /// 自定义数据
    /// </summary>
    public string CustomData { get; set; }
}

实现审计日志过滤器

using AuditLogDemo.Models;
using AuditLogDemo.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Controllers;
using Microsoft.AspNetCore.Mvc.Filters;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;

namespace AuditLogDemo.Fliters
{
    public class AuditLogActionFilter : IAsyncActionFilter
    {
        /// <summary>
        /// 审计日志服务对象
        /// </summary>
        private readonly IAuditLogService _auditLogService;
        /// <summary>
        /// 登录用户
        /// </summary>
        private readonly ISession _Session;
        /// <summary>
        /// 日志记录
        /// </summary>
        private readonly ILogger<AuditLogActionFilter> _logger;

        public AuditLogActionFilter(
            IAuditLogService auditLogService,
            ISession Session,
            ILogger<AuditLogActionFilter> logger
            )
        {
            _Session = Session;
            _logger = logger;
            _auditLogService = auditLogService;
        }

        public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
        {
            // 判断是否写日志
            if (!ShouldSaveAudit(context))
            {
                await next();
                return;
            }
            //接口Type
            var type = (context.ActionDescriptor as ControllerActionDescriptor).ControllerTypeInfo.AsType();
            //方法信息
            var method = (context.ActionDescriptor as ControllerActionDescriptor).MethodInfo;
            //方法参数
            var arguments = context.ActionArguments;
            //开始计时
            var stopwatch = Stopwatch.StartNew();
            var auditInfo = new AuditInfo
            {
                UserInfo = _Session?.Id,
                ServiceName = type != null ? type.FullName.TruncateWithPostfix(EntityDefault.FieldsLength250) : "",
                MethodName = method.Name.TruncateWithPostfix(EntityDefault.FieldsLength250),
                ////请求参数转Json
                Parameters = JsonConvert.SerializeObject(arguments),
                ExecutionTime = DateTime.Now,
                BrowserInfo = context.HttpContext.Request.Headers["User-Agent"].ToString().TruncateWithPostfix(EntityDefault.FieldsLength250),
                ClientIpAddress = context.HttpContext.Connection.RemoteIpAddress.ToString().TruncateWithPostfix(EntityDefault.FieldsLength50),
                //ClientName = _clientInfoProvider.ComputerName.TruncateWithPostfix(EntityDefault.FieldsLength100),
                Id = Guid.NewGuid().ToString()
            };

            ActionExecutedContext result = null;
            try
            {
                result = await next();
                if (result.Exception != null && !result.ExceptionHandled)
                {
                    auditInfo.Exception = result.Exception;
                }
            }
            catch (Exception ex)
            {
                auditInfo.Exception = ex;
                throw;
            }
            finally
            {
                stopwatch.Stop();
                auditInfo.ExecutionDuration = Convert.ToInt32(stopwatch.Elapsed.TotalMilliseconds);

                if (result != null)
                {
                    switch (result.Result)
                    {
                        case ObjectResult objectResult:
                            auditInfo.ReturnValue = JsonConvert.SerializeObject(objectResult.Value);
                            break;

                        case JsonResult jsonResult:
                            auditInfo.ReturnValue = JsonConvert.SerializeObject(jsonResult.Value);
                            break;

                        case ContentResult contentResult:
                            auditInfo.ReturnValue = contentResult.Content;
                            break;
                    }
                }
                Console.WriteLine(auditInfo.ToString());
                //保存审计日志
                await _auditLogService.SaveAsync(auditInfo);
            }
        }

        /// <summary>
        /// 是否需要记录审计
        /// </summary>
        /// <param name="context"></param>
        /// <returns></returns>
        private bool ShouldSaveAudit(ActionExecutingContext context)
        {
            if (!(context.ActionDescriptor is ControllerActionDescriptor))
                return false;
            var methodInfo = (context.ActionDescriptor as ControllerActionDescriptor).MethodInfo;

            if (methodInfo == null)
            {
                return false;
            }

            if (!methodInfo.IsPublic)
            {
                return false;
            }

            if (methodInfo.GetCustomAttribute<AuditedAttribute>() != null)
            {
                return true;
            }

            if (methodInfo.GetCustomAttribute<DisableAuditingAttribute>() != null)
            {
                return false;
            }

            var classType = methodInfo.DeclaringType;
            if (classType != null)
            {
                if (classType.GetTypeInfo().GetCustomAttribute<AuditedAttribute>() != null)
                {
                    return true;
                }

                if (classType.GetTypeInfo().GetCustomAttribute<AuditedAttribute>() != null)
                {
                    return false;
                }
            }
            return false;
        }
    }
}

　　　该内容为实现审计日志功能主要逻辑，通过过滤器获取当前执行控制器、方法判断是否需要记录审计日志；其他请求参数、客户端ip等相关基本信息组成审计日志对象，并记录调用时间。　

注册过滤器

public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers(options =>
    {
        options.Filters.Add(typeof(AuditLogActionFilter));
    });

    //审计日志存储
    services.AddDbContext<AuditLogDBContent>(options =>
    {
        string conn = Configuration.GetConnectionString("LogDB");
        options.UseSqlite(conn);
    });
}

　　到此审计日志主要逻辑已经实现完成。是不是很简单