dtapps
/
golog
1
0
Fork 0
Code Issues Pull Requests Projects Releases 95 Wiki Activity

- update

Browse Source
master v1.0.50
李光春 2 years ago
parent bfdf600dd3
commit acbcfac098
6 changed files with 138 additions and 227 deletions
Show Stats Download Patch File Download Diff File

139
api.go
Unescape View File

@ -6,10 +6,6 @@ import (
"go.dtapp.net/dorm"
"go.dtapp.net/goip"
"go.dtapp.net/gorequest"
"go.dtapp.net/gourl"
"go.mongodb.org/mongo-driver/bson/primitive"
"gorm.io/datatypes"
"log"
"os"
"runtime"
)
@ -132,153 +128,30 @@ func NewApiClient(config *ApiClientConfig) (*ApiClient, error) {
// Middleware 中间件
func (c *ApiClient) Middleware(ctx context.Context, request gorequest.Response, sdkVersion string) {
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
request.ResponseBody = []byte{}
}
if c.log.gorm {
err := c.gormRecord(ctx, apiPostgresqlLog{
RequestTime: request.RequestTime, //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: gourl.UriParse(request.RequestUri).Path, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestParams)), //【请求】参数
RequestHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestHeader)), //【请求】头部
ResponseHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: request.ResponseBody, //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: request.ResponseTime, //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.gormConfig.debug {
log.Printf("[log.Middleware]%s\n", err.Error())
}
}
c.GormMiddleware(ctx, request, sdkVersion)
}
if c.log.mongo {
err := c.mongoRecord(ctx, apiMongolLog{
RequestTime: primitive.NewDateTimeFromTime(request.RequestTime), //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: gourl.UriParse(request.RequestUri).Path, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: request.RequestParams, //【请求】参数
RequestHeader: request.RequestHeader, //【请求】头部
ResponseHeader: request.ResponseHeader, //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: dorm.JsonDecodeNoError(request.ResponseBody), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: primitive.NewDateTimeFromTime(request.ResponseTime), //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.mongoConfig.debug {
log.Printf("[log.Middleware]%s\n", err.Error())
}
}
c.MongoMiddleware(ctx, request, sdkVersion)
}
}
// MiddlewareXml 中间件
func (c *ApiClient) MiddlewareXml(ctx context.Context, request gorequest.Response, sdkVersion string) {
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
request.ResponseBody = []byte{}
}
if c.log.gorm {
err := c.gormRecord(ctx, apiPostgresqlLog{
RequestTime: request.RequestTime, //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: gourl.UriParse(request.RequestUri).Path, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestParams)), //【请求】参数
RequestHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestHeader)), //【请求】头部
ResponseHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: datatypes.JSON(dorm.JsonEncodeNoError(dorm.XmlDecodeNoError(request.ResponseBody))), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: request.ResponseTime, //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.gormConfig.debug {
log.Printf("[log.MiddlewareXml]%s\n", err.Error())
}
}
c.GormMiddlewareXml(ctx, request, sdkVersion)
}
if c.log.mongo {
err := c.mongoRecord(ctx, apiMongolLog{
RequestTime: primitive.NewDateTimeFromTime(request.RequestTime), //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: gourl.UriParse(request.RequestUri).Path, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: request.RequestParams, //【请求】参数
RequestHeader: request.RequestHeader, //【请求】头部
ResponseHeader: request.ResponseHeader, //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: dorm.XmlDecodeNoError(request.ResponseBody), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: primitive.NewDateTimeFromTime(request.ResponseTime), //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.mongoConfig.debug {
log.Printf("[log.MiddlewareXml]%s\n", err.Error())
}
}
c.MongoMiddlewareXml(ctx, request, sdkVersion)
}
}
// MiddlewareCustom 中间件
func (c *ApiClient) MiddlewareCustom(ctx context.Context, api string, request gorequest.Response, sdkVersion string) {
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
request.ResponseBody = []byte{}
}
if c.log.gorm {
err := c.gormRecord(ctx, apiPostgresqlLog{
RequestTime: request.RequestTime, //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: api, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestParams)), //【请求】参数
RequestHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestHeader)), //【请求】头部
ResponseHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: request.ResponseBody, //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: request.ResponseTime, //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.gormConfig.debug {
log.Printf("[log.MiddlewareCustom]%s\n", err.Error())
}
}
c.GormMiddlewareCustom(ctx, api, request, sdkVersion)
}
if c.log.mongo {
err := c.mongoRecord(ctx, apiMongolLog{
RequestTime: primitive.NewDateTimeFromTime(request.RequestTime), //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: api, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: request.RequestParams, //【请求】参数
RequestHeader: request.RequestHeader, //【请求】头部
ResponseHeader: request.ResponseHeader, //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: dorm.JsonDecodeNoError(request.ResponseBody), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: primitive.NewDateTimeFromTime(request.ResponseTime), //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.mongoConfig.debug {
log.Printf("[log.MiddlewareCustom]%s\n", err.Error())
}
}
c.MongoMiddlewareCustom(ctx, api, request, sdkVersion)
}
}

86
api_gorm.go
Unescape View File

@ -110,10 +110,7 @@ func (c *ApiClient) GormQuery() *gorm.DB {
// GormMiddleware 中间件
func (c *ApiClient) GormMiddleware(ctx context.Context, request gorequest.Response, sdkVersion string) {
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
request.ResponseBody = []byte{}
}
err := c.gormRecord(ctx, apiPostgresqlLog{
data := apiPostgresqlLog{
RequestTime: request.RequestTime, //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
@ -123,51 +120,59 @@ func (c *ApiClient) GormMiddleware(ctx context.Context, request gorequest.Respon
RequestHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestHeader)), //【请求】头部
ResponseHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: request.ResponseBody, //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: request.ResponseTime, //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.gormConfig.debug {
log.Printf("[log.GormMiddleware]%s\n", err.Error())
}
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
log.Printf("[log.GormMiddleware]：%s %s\n", data.RequestUri, request.ResponseHeader.Get("Content-Type"))
} else {
if len(dorm.JsonDecodeNoError(request.ResponseBody)) > 0 {
data.ResponseBody = request.ResponseBody //【返回】内容
} else {
log.Printf("[log.GormMiddleware]：%s %s\n", data.RequestUri, request.ResponseBody)
}
}
err := c.gormRecord(ctx, data)
if err != nil {
log.Printf("[log.GormMiddleware]：%s\n", err.Error())
}
}
// GormMiddlewareXml 中间件
func (c *ApiClient) GormMiddlewareXml(ctx context.Context, request gorequest.Response, sdkVersion string) {
data := apiPostgresqlLog{
RequestTime: request.RequestTime, //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: gourl.UriParse(request.RequestUri).Path, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestParams)), //【请求】参数
RequestHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestHeader)), //【请求】头部
ResponseHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: request.ResponseTime, //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
}
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
request.ResponseBody = []byte{}
log.Printf("[log.GormMiddlewareXml]：%s %s\n", data.RequestUri, request.ResponseHeader.Get("Content-Type"))
} else {
if len(dorm.XmlDecodeNoError(request.ResponseBody)) > 0 {
data.ResponseBody = datatypes.JSON(dorm.JsonEncodeNoError(dorm.XmlDecodeNoError(request.ResponseBody))) //【返回】内容
} else {
log.Printf("[log.GormMiddlewareXml]：%s %s\n", data.RequestUri, request.ResponseBody)
}
}
err := c.gormRecord(ctx, apiPostgresqlLog{
RequestTime: request.RequestTime, //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
RequestApi: gourl.UriParse(request.RequestUri).Path, //【请求】接口
RequestMethod: request.RequestMethod, //【请求】方式
RequestParams: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestParams)), //【请求】参数
RequestHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestHeader)), //【请求】头部
ResponseHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: datatypes.JSON(dorm.JsonEncodeNoError(dorm.XmlDecodeNoError(request.ResponseBody))), //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: request.ResponseTime, //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
err := c.gormRecord(ctx, data)
if err != nil {
if c.gormConfig.debug {
log.Printf("[log.GormMiddlewareXml]%s\n", err.Error())
}
log.Printf("[log.GormMiddlewareXml]：%s\n", err.Error())
}
}
// GormMiddlewareCustom 中间件
func (c *ApiClient) GormMiddlewareCustom(ctx context.Context, api string, request gorequest.Response, sdkVersion string) {
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
request.ResponseBody = []byte{}
}
err := c.gormRecord(ctx, apiPostgresqlLog{
data := apiPostgresqlLog{
RequestTime: request.RequestTime, //【请求】时间
RequestUri: request.RequestUri, //【请求】链接
RequestUrl: gourl.UriParse(request.RequestUri).Url, //【请求】链接
@ -177,14 +182,21 @@ func (c *ApiClient) GormMiddlewareCustom(ctx context.Context, api string, reques
RequestHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.RequestHeader)), //【请求】头部
ResponseHeader: datatypes.JSON(dorm.JsonEncodeNoError(request.ResponseHeader)), //【返回】头部
ResponseStatusCode: request.ResponseStatusCode, //【返回】状态码
ResponseBody: request.ResponseBody, //【返回】内容
ResponseContentLength: request.ResponseContentLength, //【返回】大小
ResponseTime: request.ResponseTime, //【返回】时间
SdkVersion: sdkVersion, //【程序】Sdk版本
})
if err != nil {
if c.gormConfig.debug {
log.Printf("[log.GormMiddlewareCustom]%s\n", err.Error())
}
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
log.Printf("[log.GormMiddlewareCustom]：%s %s\n", data.RequestUri, request.ResponseHeader.Get("Content-Type"))
} else {
if len(dorm.JsonDecodeNoError(request.ResponseBody)) > 0 {
data.ResponseBody = request.ResponseBody //【返回】内容
} else {
log.Printf("[log.GormMiddlewareCustom]：%s %s\n", data.RequestUri, request.ResponseBody)
}
}
err := c.gormRecord(ctx, data)
if err != nil {
log.Printf("[log.GormMiddlewareCustom]：%s\n", err.Error())
}
}

21
api_mongo.go
Unescape View File

@ -179,8 +179,13 @@ func (c *ApiClient) MongoMiddleware(ctx context.Context, request gorequest.Respo
SdkVersion: sdkVersion, //【程序】Sdk版本
}
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
log.Printf("[log.MongoMiddleware]：%s %s\n", data.RequestUri, request.ResponseHeader.Get("Content-Type"))
} else {
data.ResponseBody = dorm.JsonDecodeNoError(request.ResponseBody) //【返回】内容
if len(dorm.JsonDecodeNoError(request.ResponseBody)) > 0 {
data.ResponseBody = dorm.JsonDecodeNoError(request.ResponseBody) //【返回】内容
} else {
log.Printf("[log.MongoMiddleware]：%s %s\n", data.RequestUri, request.ResponseBody)
}
}
err := c.mongoRecord(ctx, data)
if err != nil {
@ -205,8 +210,13 @@ func (c *ApiClient) MongoMiddlewareXml(ctx context.Context, request gorequest.Re
SdkVersion: sdkVersion, //【程序】Sdk版本
}
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
log.Printf("[log.MongoMiddlewareXml]：%s %s\n", data.RequestUri, request.ResponseHeader.Get("Content-Type"))
} else {
data.ResponseBody = dorm.XmlDecodeNoError(request.ResponseBody) //【返回】内容
if len(dorm.XmlDecodeNoError(request.ResponseBody)) > 0 {
data.ResponseBody = dorm.XmlDecodeNoError(request.ResponseBody) //【返回】内容
} else {
log.Printf("[log.MongoMiddlewareXml]：%s %s\n", data.RequestUri, request.ResponseBody)
}
}
err := c.mongoRecord(ctx, data)
if err != nil {
@ -231,8 +241,13 @@ func (c *ApiClient) MongoMiddlewareCustom(ctx context.Context, api string, reque
SdkVersion: sdkVersion, //【程序】Sdk版本
}
if request.ResponseHeader.Get("Content-Type") == "image/jpeg" || request.ResponseHeader.Get("Content-Type") == "image/png" || request.ResponseHeader.Get("Content-Type") == "image/jpg" {
log.Printf("[log.MongoMiddlewareCustom]：%s %s\n", data.RequestUri, request.ResponseHeader.Get("Content-Type"))
} else {
data.ResponseBody = dorm.JsonDecodeNoError(request.ResponseBody) //【返回】内容
if len(dorm.JsonDecodeNoError(request.ResponseBody)) > 0 {
data.ResponseBody = dorm.JsonDecodeNoError(request.ResponseBody) //【返回】内容
} else {
log.Printf("[log.MongoMiddlewareCustom]：%s %s\n", data.RequestUri, request.ResponseBody)
}
}
err := c.mongoRecord(ctx, data)
if err != nil {

2
const.go
Unescape View File

@ -1,5 +1,5 @@
package golog
const (
Version = "1.0.49"
Version = "1.0.50"
)

58
gin_gorm.go
Unescape View File

@ -120,23 +120,15 @@ func (c *GinClient) gormRecord(postgresqlLog ginPostgresqlLog) error {
}
func (c *GinClient) gormRecordJson(ginCtx *gin.Context, traceId string, requestTime time.Time, requestBody map[string]interface{}, responseCode int, responseBody string, startTime, endTime int64, clientIp, requestClientIpCountry, requestClientIpRegion, requestClientIpProvince, requestClientIpCity, requestClientIpIsp string) {
host := ""
if ginCtx.Request.TLS == nil {
host = "http://" + ginCtx.Request.Host
} else {
host = "https://" + ginCtx.Request.Host
}
err := c.gormRecord(ginPostgresqlLog{
data := ginPostgresqlLog{
TraceId: traceId, //【系统】跟踪编号
RequestTime: requestTime, //【请求】时间
RequestUri: host + ginCtx.Request.RequestURI, //【请求】请求链接
RequestUrl: ginCtx.Request.RequestURI, //【请求】请求链接
RequestApi: gourl.UriFilterExcludeQueryString(ginCtx.Request.RequestURI), //【请求】请求接口
RequestMethod: ginCtx.Request.Method, //【请求】请求方式
RequestProto: ginCtx.Request.Proto, //【请求】请求协议
RequestUa: ginCtx.Request.UserAgent(), //【请求】请求UA
RequestReferer: ginCtx.Request.Referer(), //【请求】请求referer
RequestBody: datatypes.JSON(dorm.JsonEncodeNoError(requestBody)), //【请求】请求主体
RequestUrlQuery: datatypes.JSON(dorm.JsonEncodeNoError(ginCtx.Request.URL.Query())), //【请求】请求URL参数
RequestIp: clientIp, //【请求】请求客户端Ip
RequestIpCountry: requestClientIpCountry, //【请求】请求客户端城市
@ -149,32 +141,35 @@ func (c *GinClient) gormRecordJson(ginCtx *gin.Context, traceId string, requestT
ResponseCode: responseCode, //【返回】状态码
ResponseData: datatypes.JSON(responseBody), //【返回】数据
CostTime: endTime - startTime, //【系统】花费时间
})
}
if ginCtx.Request.TLS == nil {
data.RequestUri = "http://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
} else {
data.RequestUri = "https://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
}
if len(dorm.JsonEncodeNoError(requestBody)) > 0 {
data.RequestBody = datatypes.JSON(dorm.JsonEncodeNoError(requestBody)) //【请求】请求主体
} else {
log.Printf("[log.gormRecordJson]：%s %s\n", data.RequestUri, requestBody)
}
err := c.gormRecord(data)
if err != nil {
if c.gormConfig.debug {
log.Printf("[golog.gormRecordJson] %s\n", err)
}
log.Printf("[golog.gormRecordJson]：%s\n", err)
}
}
func (c *GinClient) gormRecordXml(ginCtx *gin.Context, traceId string, requestTime time.Time, requestBody map[string]string, responseCode int, responseBody string, startTime, endTime int64, clientIp, requestClientIpCountry, requestClientIpRegion, requestClientIpProvince, requestClientIpCity, requestClientIpIsp string) {
host := ""
if ginCtx.Request.TLS == nil {
host = "http://" + ginCtx.Request.Host
} else {
host = "https://" + ginCtx.Request.Host
}
err := c.gormRecord(ginPostgresqlLog{
data := ginPostgresqlLog{
TraceId: traceId, //【系统】跟踪编号
RequestTime: requestTime, //【请求】时间
RequestUri: host + ginCtx.Request.RequestURI, //【请求】请求链接
RequestUrl: ginCtx.Request.RequestURI, //【请求】请求链接
RequestApi: gourl.UriFilterExcludeQueryString(ginCtx.Request.RequestURI), //【请求】请求接口
RequestMethod: ginCtx.Request.Method, //【请求】请求方式
RequestProto: ginCtx.Request.Proto, //【请求】请求协议
RequestUa: ginCtx.Request.UserAgent(), //【请求】请求UA
RequestReferer: ginCtx.Request.Referer(), //【请求】请求referer
RequestBody: datatypes.JSON(dorm.JsonEncodeNoError(requestBody)), //【请求】请求主体
RequestUrlQuery: datatypes.JSON(dorm.JsonEncodeNoError(ginCtx.Request.URL.Query())), //【请求】请求URL参数
RequestIp: clientIp, //【请求】请求客户端Ip
RequestIpCountry: requestClientIpCountry, //【请求】请求客户端城市
@ -187,11 +182,22 @@ func (c *GinClient) gormRecordXml(ginCtx *gin.Context, traceId string, requestTi
ResponseCode: responseCode, //【返回】状态码
ResponseData: datatypes.JSON(responseBody), //【返回】数据
CostTime: endTime - startTime, //【系统】花费时间
})
}
if ginCtx.Request.TLS == nil {
data.RequestUri = "http://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
} else {
data.RequestUri = "https://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
}
if len(dorm.JsonEncodeNoError(requestBody)) > 0 {
data.RequestBody = datatypes.JSON(dorm.JsonEncodeNoError(requestBody)) //【请求】请求主体
} else {
log.Printf("[log.gormRecordXml]：%s %s\n", data.RequestUri, requestBody)
}
err := c.gormRecord(data)
if err != nil {
if c.gormConfig.debug {
log.Printf("[golog.gormRecordXml] %s\n", err)
}
log.Printf("[golog.gormRecordXml]：%s\n", err)
}
}

59
gin_mongo.go
Unescape View File

@ -217,24 +217,15 @@ func (c *GinClient) mongoRecord(mongoLog ginMongoLog) error {
}
func (c *GinClient) mongoRecordJson(ginCtx *gin.Context, traceId string, requestTime time.Time, requestBody map[string]interface{}, responseCode int, responseBody string, startTime, endTime int64, clientIp, requestClientIpCountry, requestClientIpRegion, requestClientIpProvince, requestClientIpCity, requestClientIpIsp string) {
host := ""
if ginCtx.Request.TLS == nil {
host = "http://" + ginCtx.Request.Host
} else {
host = "https://" + ginCtx.Request.Host
}
err := c.mongoRecord(ginMongoLog{
data := ginMongoLog{
TraceId: traceId, //【系统】跟踪编号
RequestTime: primitive.NewDateTimeFromTime(requestTime), //【请求】时间
RequestUri: host + ginCtx.Request.RequestURI, //【请求】请求链接
RequestUrl: ginCtx.Request.RequestURI, //【请求】请求链接
RequestApi: gourl.UriFilterExcludeQueryString(ginCtx.Request.RequestURI), //【请求】请求接口
RequestMethod: ginCtx.Request.Method, //【请求】请求方式
RequestProto: ginCtx.Request.Proto, //【请求】请求协议
RequestUa: ginCtx.Request.UserAgent(), //【请求】请求UA
RequestReferer: ginCtx.Request.Referer(), //【请求】请求referer
RequestBody: requestBody, //【请求】请求主体
RequestUrlQuery: ginCtx.Request.URL.Query(), //【请求】请求URL参数
RequestIp: clientIp, //【请求】请求客户端Ip
RequestIpCountry: requestClientIpCountry, //【请求】请求客户端城市
@ -247,32 +238,35 @@ func (c *GinClient) mongoRecordJson(ginCtx *gin.Context, traceId string, request
ResponseCode: responseCode, //【返回】状态码
ResponseData: c.jsonUnmarshal(responseBody), //【返回】数据
CostTime: endTime - startTime, //【系统】花费时间
})
}
if ginCtx.Request.TLS == nil {
data.RequestUri = "http://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
} else {
data.RequestUri = "https://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
}
if len(dorm.JsonEncodeNoError(requestBody)) > 0 {
data.RequestBody = requestBody //【请求】请求主体
} else {
log.Printf("[log.mongoRecordJson]：%s %s\n", data.RequestUri, requestBody)
}
err := c.mongoRecord(data)
if err != nil {
if c.mongoConfig.debug {
log.Printf("[golog.mongoRecordJson] %s\n", err)
}
log.Printf("[golog.mongoRecordJson]：%s\n", err)
}
}
func (c *GinClient) mongoRecordXml(ginCtx *gin.Context, traceId string, requestTime time.Time, requestBody map[string]string, responseCode int, responseBody string, startTime, endTime int64, clientIp, requestClientIpCountry, requestClientIpRegion, requestClientIpProvince, requestClientIpCity, requestClientIpIsp string) {
host := ""
if ginCtx.Request.TLS == nil {
host = "http://" + ginCtx.Request.Host
} else {
host = "https://" + ginCtx.Request.Host
}
err := c.mongoRecord(ginMongoLog{
data := ginMongoLog{
TraceId: traceId, //【系统】跟踪编号
RequestTime: primitive.NewDateTimeFromTime(requestTime), //【请求】时间
RequestUri: host + ginCtx.Request.RequestURI, //【请求】请求链接
RequestUrl: ginCtx.Request.RequestURI, //【请求】请求链接
RequestApi: gourl.UriFilterExcludeQueryString(ginCtx.Request.RequestURI), //【请求】请求接口
RequestMethod: ginCtx.Request.Method, //【请求】请求方式
RequestProto: ginCtx.Request.Proto, //【请求】请求协议
RequestUa: ginCtx.Request.UserAgent(), //【请求】请求UA
RequestReferer: ginCtx.Request.Referer(), //【请求】请求referer
RequestBody: requestBody, //【请求】请求主体
RequestUrlQuery: ginCtx.Request.URL.Query(), //【请求】请求URL参数
RequestIp: clientIp, //【请求】请求客户端Ip
RequestIpCountry: requestClientIpCountry, //【请求】请求客户端城市
@ -285,11 +279,22 @@ func (c *GinClient) mongoRecordXml(ginCtx *gin.Context, traceId string, requestT
ResponseCode: responseCode, //【返回】状态码
ResponseData: c.jsonUnmarshal(responseBody), //【返回】数据
CostTime: endTime - startTime, //【系统】花费时间
})
}
if ginCtx.Request.TLS == nil {
data.RequestUri = "http://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
} else {
data.RequestUri = "https://" + ginCtx.Request.Host + ginCtx.Request.RequestURI //【请求】请求链接
}
if len(dorm.JsonEncodeNoError(requestBody)) > 0 {
data.RequestBody = requestBody //【请求】请求主体
} else {
log.Printf("[log.mongoRecordXml]：%s %s\n", data.RequestUri, requestBody)
}
err := c.mongoRecord(data)
if err != nil {
if c.mongoConfig.debug {
log.Printf("[golog.mongoRecordXml] %s\n", err)
}
log.Printf("[golog.mongoRecordXml]：%s\n", err)
}
}

Write Preview
Loading…
Cancel
Save