基于Laravel封装一个强大的请求响应日志记录中间件

为何强大

1. 记录全面： 包含请求路径、请求方法、客户端IP、设备标识、荷载数据、文件上传、请求头、业务逻辑处理时间、业务逻辑所耗内存、用户id、HTTP响应状态码、以及响应数据。
2. 配置简单： 默认不需要写任何逻辑可开箱即用，靠前5个方法，就可指定某些url不记录日志，某些url不记录响应日志、或不记录某些请求头，不记录某些荷载数据，或决定是否返回非json类型的响应数据。
3. 清晰简洁： 返回的每项数据都是json或者字符串，一行一项数据，且缩进一致，清晰明了。该有的展示项都有，该忽略的展示项已经被忽略。
4. 规范统一： 无论请求数据是什么格式，最后到日志的数据之有字符串或json两种格式，避免五花八门的数据造成日志格式混乱。
5. 强兼容性： 无论是什么请求方式（GET、POST、DELETE、PATCH、PUT、OPTIONS等），或者传递什么内容类型（x-www-form-urlencoded、multipart/form-data、json、xml、纯文本），日志都可记录，适用于多数项目场景。
6. 灵活扩展： 对中间件前5个配置相关的方法，引入了Request对象，方便根据此对象实现更复杂的逻辑。
7. 方便调试： 当项目出问题时，有日志参考是必须的，结合"tail -f"，或者日志查看器插件更是如虎添翼。
8. 日志隔离： 利用laravel强大的日志渠道隔离和按天切割功能，使得记录日志过程更加强大。

效果示例

[2023-12-29 06:53:34] local.INFO: 
url      : http://laravel.test/api/test?k1=v1&k2=v2
method   : POST
ip       : 127.0.0.1
ua       : PostmanRuntime-ApipostRuntime/1.1.0
payload  : {"key1":"val1","key2":"val2"}
file     : {"file":["测试图片1.jpeg","测试图片2.jpeg"]}
header   : {"content-type":"multipart\/form-data; boundary=--------------------------771657688394796615738323"}
user_id  : 0
time     : 53.10
mem      : 15.54 MB
code     : 200
response : {"code":0,"msg":"","data":[]}
1
2
3
4
5
6
7
8
9
10
11
12
13

部署

#在config/logging.php中的channels项添加如下配置
'request' => [
    'driver' => 'daily',
    'path' => storage_path('logs/request.log'),
    'level' => env('LOG_LEVEL', 'debug'),
    'days' => 3,
    'permission' => 0777
],

#进入laravel所在目录，用artisan命令创建中间件
php artisan make:middleware RequestMiddleware
1
2
3
4
5
6
7
8
9
10
11

//在app/Http/Kernel.php文件的protected $middleware数组中追加一行，用于注册全局中间件
\App\Http\Middleware\RequestMiddleware::class
1
2

编写

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Log;
/**
 * @Class   RequestMiddleware 记录请求日志，方便开发者调试
 * @package App\Http\Middleware
 */
class RequestMiddleware {
    /**
     * @function 设置不记录日志的url
     * @param    \Illuminate\Http\Request $request
     * @return   array
     * @other    排除规则依照request()->is()方法
     */
    private function setExceptUrl($request) {
        return [
            'admin/logs*', 'admin/logs/*',
        ];
    }


    /**
     * @function 设置不记录响应日志的url
     * @param    \Illuminate\Http\Request $request
     * @return   array
     * @other    排除规则依照request()->is()方法
     */
    private function setExceptRecordResponseDataUrl($request) {
        return [

        ];
    }


    /**
     * @function 设置不记录的荷载项
     * @param    \Illuminate\Http\Request $request
     * @return   array
     * @other    比如防止CSRF的_token
     */
    private function setExceptPayload($request) {
        return [
            '_token', '_method'
        ];
    }


    /**
     * @function 设置不记录日志的请求头
     * @param    \Illuminate\Http\Request $request
     * @return   array
     * @other    void
     */
    private function setExceptHeader($request) {
        return [
            //官方
            'accept', 'accept-encoding', 'accept-language', 'authorization',
            'access-control-allow-credentials', 'access-control-allow-headers', 'access-control-allow-methods', 'access-control-allow-origin',
            'access-control-expose-headers', 'access-control-max-age', 'access-control-request-headers', 'access-control-request-method',
            'cache-control', 'charset', 'connection', 'content-length', 'content-type_except', 'cookie',
            'host', 'origin', 'pragma', 'referer',
            'sec-ch-ua', 'sec-ch-ua-mobile', 'sec-ch-ua-platform', 'sec-fetch-dest', 'sec-fetch-mode', 'sec-fetch-site',
            'upgrade-insecure-requests', 'user-agent', 'x-forwarded-for', 'x-forwarded-host', 'x-forwarded-port', 'x-forwarded-proto', 'x-requested-with',
            //自定义
        ];
    }


    /**
     * @function 是否记录非json格式的响应的数据
     * @param    \Illuminate\Http\Request $request
     * @return   bool
     * @other    void
     */
    private function isRecordNotJsonResponseData($request) {
        return false;
    }
//------------------------------------------------此分割线以下代码无需修改------------------------------------------------
    /**
     * @function 请求日志中间件
     * @param    \Illuminate\Http\Request $request
     * @param    \Closure(\Illuminate\Http\Request):(\Illuminate\Http\Response|\Illuminate\Http\RedirectResponse) $next
     * @return   \Illuminate\Http\Response|\Illuminate\Http\RedirectResponse
     * @other    void
     */
    public function handle(Request $request, Closure $next) {
        if($this->getExceptUrl($request)) {
            return $next($request);
        }

        $request_and_response = [
            'url'      => $this->getFullUrl($request),
            'method'   => $this->getRequestMethod($request),
            'ip'       => $this->getClientIp($request),
            'ua'       => $this->getUa($request),
            'payload'  => $this->getRequestPayload($request),
            'file'     => $this->getClearRequestFile($request),
            'header'   => $this->getClearRequestHeader($request),
            'time'     => 0,
            'mem'      => '0B',
            'code'     => 0,
            'response' => '""',
        ];

        $is_except_record_response_data_url = $this->getExceptRecordResponseDataUrl($request);
        if($is_except_record_response_data_url) {
            Log::channel('request')->info($this->dataFormat($request_and_response));
        }

        $start     = microtime(true);
        $response  = $next($request);
        $end       = microtime(true);
        
        if(! $is_except_record_response_data_url) {
            $request_and_response['time']     = bcmul(bcsub($end, $start, 6), 1000, 2);
            $request_and_response['mem']      = $this->getUsageMemory();
            $request_and_response['code']     = $this->getHttpCode($response);
            $request_and_response['response'] = $this->responseFormat($request, $response);

            Log::channel('request')->info($this->dataFormat($request_and_response));
        }

        return $response;
    }


    /**
     * @function 获取不记录日志的url
     * @param    \Illuminate\Http\Request $request
     * @return   bool
     * @other    void
     */
    private function getExceptUrl($request) {
        $blacklist = array_filter($this->setExceptUrl($request));
        if(! $blacklist) {
            return false;
        }

        foreach($blacklist as $every_blacklist) {
            if($request->is($every_blacklist)) {
                return true;
            }
        }

        return false;
    }


    /**
     * @function 获取不记录响应日志的url
     * @param    \Illuminate\Http\Request $request
     * @return   bool
     * @other    void
     */
    private function getExceptRecordResponseDataUrl($request) {
        $blacklist = array_filter($this->setExceptRecordResponseDataUrl($request));
        if(! $blacklist) {
            return false;
        }

        foreach($blacklist as $every_blacklist) {
            if($request->is($every_blacklist)) {
                return true;
            }
        }

        return false;
    }


    /**
     * @function 获取完整的请求路径
     * @param    \Illuminate\Http\Request $request
     * @return   string
     * @other    void
     */
    private function getFullUrl($request) {
        return urldecode($request->fullUrl());
    }


    /**
     * @function 获取请求方式
     * @param    \Illuminate\Http\Request $request
     * @return   string
     * @other    由于laravel存在_method覆盖机制，若有括号，则括号内的为真正的请求方式
     */
    private function getRequestMethod($request) {
        $real_method = $_SERVER['REQUEST_METHOD'] ?? '';

        //防止乱传参导致的错误
        try{
            $laravel_method = $request->method();
        } catch (\Exception $exception) {
            $laravel_method = $real_method;
        }

        if($real_method === $laravel_method) {
            return $real_method;
        }

        return "{$laravel_method}({$real_method})";
    }


    /**
     * @function 获取客户端的IP
     * @param    \Illuminate\Http\Request $request
     * @return   string
     * @other    void
     */
    private function getClientIp($request) {
        return $request->getClientIp();
    }


    /**
     * @function 获取用户代理
     * @param    \Illuminate\Http\Request  $request
     * @return   string
     * @other    void
     */
    private function getUa($request) {
        return $request->header('user-agent') ?? '""';
    }


    /**
     * @function 获取请求荷载，包含x-www-form-urlencoded、multipart/form-data、application/json、application/xml等纯文本荷载数据
     * @param    \Illuminate\Http\Request  $request
     * @return   array
     * @other    void
     */
    private function getRequestPayload($request) {
        if($request->method() === 'GET') {
            return [];
        }
        $except = collect($request->query())->keys()->merge($this->setExceptPayload($request))->filter();
        $input  = collect($request->input())->except($except)->map(function ($val) {
            if (is_null($val)) {
                return '';
            }
            return $val;
        })->toArray();

        if($input) {
            return $input;
        }

        $raw = $request->getContent();
        //兼容application/xml、text/xml
        if(strstr($request->header('content-type'), 'xml')) {
            if(! $raw) {
                return [];
            }
            if(! $this->isXml($raw)) {
                return [$raw];
            }
            return json_decode(json_encode(simplexml_load_string(str_replace(["\r", "\n"], '', $raw))), true);
        }

        return array_filter([$raw]);
    }


    /**
     * @function 获取简洁的文件上传数据
     * @param    \Illuminate\Http\Request $request
     * @return   array
     * @other    void
     */
    private function getClearRequestFile($request) {
        return collect($request->allFiles())->map(function($val) {
            if(is_array($val)) {
                $res = collect($val)->map(function($v) {
                    return $v->getClientOriginalName();
                });
            } else {
                $res = $val->getClientOriginalName();
            }
            return $res;
        })->toArray();
    }


    /**
     * @function 获取干净的请求头
     * @param    \Illuminate\Http\Request $request
     * @return   array
     * @other    void
     */
    private function getClearRequestHeader($request) {
        return collect($request->header())->except(array_filter($this->setExceptHeader($request)))->map(function($every_header, $key) {
            return (count($every_header) === 1) ? collect($every_header)->values()->first() : $every_header;
        })->toArray();
    }


    /**
     * @function 通过token获取user_id，这个有伪造的风险
     * @param    \Illuminate\Http\Request $request
     * @return   int
     * @other    void
     */
    private function getIdWithToken($request) {
        $token = $request->header('authorization');
        if(! $token) {
            return 0;
        }

        $payload = (explode('.', $token)[1]) ?? null;
        if(is_null($payload)) {
            return 0;
        }

        $json = base64_decode($payload);
        $arr  = json_decode($json, true);
        if(is_null($arr)) {
            return 0;
        }

        return $arr['sub'] ?? 0;
    }


    /**
     * @function 获取状态码
     * @param    \Illuminate\Http\JsonResponse|\Illuminate\Http\Response $response
     * @return   string|array
     * @other    void
     */
    private function getHttpCode($response) {
        return $response->getStatusCode();
    }


    /**
     * @function 格式化响应数据
     * @param    \Illuminate\Http\Request $request
     * @param    \Illuminate\Http\JsonResponse|\Illuminate\Http\Response $response
     * @return   string|array
     * @other    void
     */
    private function responseFormat($request, $response) {
        if($response instanceof \Illuminate\Http\JsonResponse) {
            return collect($response->getData())->toArray();
        }

        if(! $this->isRecordNotJsonResponseData($request)) {
            return '""';
        }

        if($response instanceof \Illuminate\Http\Response) {
            return $response->getContent();
        }

        return '""';
    }


    /**
     * @function 格式化数组并转换为字符串
     * @param    $request_and_response array
     * @return   string
     * @other    void
     */
    private function dataFormat($request_and_response) {
        $str = "\n";
        foreach($request_and_response as $k => $v) {
            $k = str_pad($k, 9, ' ', STR_PAD_RIGHT);
            $v = is_array($v) ? json_encode($v, JSON_UNESCAPED_UNICODE) : $v;
            $str .= "{$k}: {$v}\n";
        }

        return $str;
    }


    /**
     * @function 获取程序占用的内存
     * @return   string
     * @other    void
     */
    private function getUsageMemory() {
        $bytes = memory_get_usage();
        $units = ['B', 'KB', 'MB', 'GB', 'TB'];
        $bytes /= pow(1024, ($i = floor(log($bytes, 1024))));
        return round($bytes, 2) . ' ' . $units[$i];
    }


    /**
     * @function 判断是否是xml
     * @param    $str string 要判断的xml数据
     * @return   bool
     */
    private function isXml($str) {
        libxml_use_internal_errors(true);
        simplexml_load_string($str);
        $errors = libxml_get_errors();
        libxml_clear_errors();
        return ! $errors;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408

说明

1. 文章的每个方法都加了清晰的注释，且拆分的非常详细，便于二次开发，像是getUsageMemory()，isXml()，方法都可以封装到公共的工具库中。
2. user_id项是因为项目使用jwt，为了方便调试，临时加的。考虑到性能问题没做验签，所以user_id有被伪造的可能。
3. 此模块经受过时间的考验，目前没有因为不兼容导致此中间件报错的情况，每个项目值得拥有。
4. 考虑到磁盘IO的开销，可以将日志存入Redis。这里有两种操作方案：
   • 方案1. 设置好存储日志数量的阈值，日志数量到阈值后再一次性批量存入磁盘，然后清除已经存储在磁盘上的的redis日志数据，但是日志数量不够阈值时，就不会自动保存到磁盘，可添加一个自定义artisan指令来解决剩余数量的日志存储问题。
   • 方案2. 写一个计划任务，利用定时器功能每隔一段时间获取Redis上的日志，如果有日志，则批量保存单位时间内的redis数据到日志，并清除单位时间内redis中保存的日志内容。
5. json精度问题：
   前后端分离的架构，大数据在传参时时使用json会产生精度误差问题,导致日志记录不精确，如下：

// [1.2345678912345678e+17]
echo json_encode([123456789123456789.123456789123456789]);
//Array ( [0] => 1.2345678912346E+17 )
print_r(json_decode('[123456789123456789.123456789123456789]', true));
1
2
3
4

这个是编程语言层面的问题，所以在传输大数据时一定要转化为字符串去解决精度问题。

// ["123456789123456789.123456789123456789"]
echo json_encode(["123456789123456789.123456789123456789"]);
//Array ( [0] => 123456789123456789.123456789123456789)
print_r(json_decode('["123456789123456789.123456789123456789"]', true));
1
2
3
4