public async Task AddRequestInfoAsync(IRequestInfo request, IRequestDetail detail)
{
if (Options.EnableDefer)
{
_deferFlushCollection.Flush(request, detail);
}
else
{
await Client.IndexAsync <RequestInfo>(request as RequestInfo, x => x.Index(GetIndexName <RequestInfo>()));
await Client.IndexAsync <RequestDetail>(detail as RequestDetail, x => x.Index(GetIndexName <RequestDetail>()));
}
}
public async Task AddRequestInfoAsync(IRequestInfo request, IRequestDetail detail)
{
if (_options.EnableDefer)
{
_deferFlushCollection.Push(request, detail);
}
else
{
await LoggingSqlOperation(async connection =>
{
await connection.ExecuteAsync("INSERT INTO [RequestInfo] (Id,ParentId,Node,Route,Url,RequestType,Method,Milliseconds,StatusCode,IP,Port,LocalIP,LocalPort,CreateTime) VALUES (@Id,@ParentId,@Node, @Route, @Url,@RequestType, @Method, @Milliseconds, @StatusCode, @IP,@Port,@LocalIP,@LocalPort,@CreateTime)", request).ConfigureAwait(false);
await connection.ExecuteAsync("INSERT INTO [RequestDetail] (Id,RequestId,Scheme,QueryString,Header,Cookie,RequestBody,ResponseBody,ErrorMessage,ErrorStack,CreateTime) VALUES (@Id,@RequestId,@Scheme,@QueryString,@Header,@Cookie,@RequestBody,@ResponseBody,@ErrorMessage,@ErrorStack,@CreateTime)", detail).ConfigureAwait(false);
}, "请求数据保存失败").ConfigureAwait(false);
}
}
protected override (IRequestInfo, IRequestDetail) Build(HttpContext context, IRequestInfo request, string path)
{
if (Options.Node.IsEmpty())
{
Options.Node = "Default";
}
request.Node = Options.Node.Substring(0, 1).ToUpper() + Options.Node.Substring(1).ToLower();
request.Route = GetRoute(path);
IRequestDetail requestDetail = GetRequestDetail(context, request);
requestDetail.RequestId = request.Id = MD5_16(Guid.NewGuid().ToString());
return(request, requestDetail);
}
public async Task AddRequestInfoAsync(IRequestInfo request, IRequestDetail detail)
{
if (Options.EnableDefer)
{
_deferFlushCollection.Push(request, detail);
}
else
{
await LoggingSqlOperation(async connection =>
{
await connection.ExecuteAsync("INSERT INTO `RequestInfo` (`Id`,`ParentId`,`Node`, `Route`, `Url`, `RequestType`, `Method`, `Milliseconds`, `StatusCode`, `IP`,`Port`,`LocalIP`,`LocalPort`,`CreateTime`) VALUES (@Id,@ParentId, @Node, @Route, @Url,@RequestType, @Method, @Milliseconds, @StatusCode, @IP,@Port,@LocalIP,@LocalPort, @CreateTime)", request).ConfigureAwait(false);
await connection.ExecuteAsync("INSERT INTO `RequestDetail` (`Id`,`RequestId`,`Scheme`,`QueryString`,`Header`,`Cookie`,`RequestBody`,`ResponseBody`,`ErrorMessage`,`ErrorStack`,`CreateTime`) VALUES (@Id,@RequestId,@Scheme,@QueryString,@Header,@Cookie,@RequestBody,@ResponseBody,@ErrorMessage,@ErrorStack,@CreateTime)", detail).ConfigureAwait(false);
}, "请求数据保存失败").ConfigureAwait(false);
}
}
protected override (IRequestInfo, IRequestDetail) Build(HttpContext context, IRequestInfo request, string path)
{
if (Options.Service.IsEmpty())
{
Options.Service = Options.Node.IsEmpty() ? "Default":Options.Node;
}
request.Node = Options.Service.Substring(0, 1).ToUpper() + Options.Service.Substring(1).ToLower();
request.Route = GetRoute(path);
IRequestDetail requestDetail = GetRequestDetail(context, request);
requestDetail.RequestId = request.Id = Activity.Current.SpanId.ToHexString();
request.ParentId = Activity.Current.ParentId == null ? string.Empty : Activity.Current.ParentSpanId.ToHexString();
return(request, requestDetail);
}
protected override (IRequestInfo, IRequestDetail) Build(HttpContext context, IRequestInfo request, string path)
{
if (Options.Service.IsEmpty())
{
Options.Service = Options.Node.IsEmpty() ? "Default":Options.Node;
}
request.Node = Options.Service.Substring(0, 1).ToUpper() + Options.Service.Substring(1);
request.Route = GetRoute(path);
IRequestDetail requestDetail = GetRequestDetail(context, request);
requestDetail.RequestId = request.Id = context.GetTraceId();
request.ParentId = context.GetTraceParentId();
return(request, requestDetail);
}
public async Task AddRequestInfoAsync(IRequestInfo request, IRequestDetail detail)
{
if (_options.EnableDefer)
{
_deferFlushCollection.Push(request, detail);
}
else
{
await LoggingSqlOperation(async connection =>
{
string requestSql = $@"Insert Into RequestInfo Values ('{request.Id}','{request.Node}','{request.Route}','{request.Url}','{request.Method}',{request.Milliseconds},{request.StatusCode},'{request.IP}',to_date('{request.CreateTime.ToString("yyyy-MM-dd HH:mm:ss")}','yyyy-mm-dd hh24:mi:ss'))";
await connection.ExecuteAsync(requestSql).ConfigureAwait(false);
string detailSql = $@"Insert Into RequestDetail Values ('{detail.Id}','{detail.RequestId}','{detail.Scheme}','{detail.QueryString}','{detail.Header}','{detail.Cookie}','{detail.RequestBody}','{detail.ResponseBody}','{detail.ErrorMessage}','{detail.ErrorStack}',to_date('{detail.CreateTime.ToString("yyyy-MM-dd HH:mm:ss")}','yyyy-mm-dd hh24:mi:ss')) ";
await connection.ExecuteAsync(detailSql).ConfigureAwait(false);
}, "请求数据保存失败").ConfigureAwait(false);
}
}
private IRequestDetail CutRequestDetail(IRequestDetail detail)
{
int OracleMaxClob = 4000;
if (detail.QueryString.Length > OracleMaxClob)
{
detail.QueryString = detail.QueryString.Substring(0, OracleMaxClob);
}
if (detail.Header.Length > OracleMaxClob)
{
detail.Header = detail.Header.Substring(0, OracleMaxClob);
}
if (detail.Cookie.Length > OracleMaxClob)
{
detail.Cookie = detail.Cookie.Substring(0, OracleMaxClob);
}
if (detail.RequestBody.Length > OracleMaxClob)
{
detail.RequestBody = detail.RequestBody.Substring(0, OracleMaxClob);
}
if (detail.ResponseBody.Length > OracleMaxClob)
{
detail.ResponseBody = detail.ResponseBody.Substring(0, OracleMaxClob);
}
if (detail.ErrorMessage.Length > OracleMaxClob)
{
detail.ErrorMessage = detail.ErrorMessage.Substring(0, OracleMaxClob);
}
if (detail.ErrorStack.Length > OracleMaxClob)
{
detail.ErrorStack = detail.ErrorStack.Substring(0, OracleMaxClob);
}
return(detail);
}
public async Task AddRequestInfoAsync(IRequestInfo request, IRequestDetail detail)
{
detail = CutRequestDetail(detail);
if (_options.EnableDefer)
{
_deferFlushCollection.Push(request, detail);
}
else
{
await LoggingSqlOperation(async _ =>
{
string requestSql = $@"Insert Into RequestInfo Values (:Id,:ParentId, :Node, :Route, :Url,:RequestType,:Method, :Milliseconds, :StatusCode, :IP,:Port,:LocalIP,:LocalPort,:CreateTime) ";
await _.ExecuteAsync(requestSql, request);
string detailSql = $@"Insert Into RequestDetail Values (:Id,:RequestId,:Scheme,:QueryString,:Header,:Cookie,:RequestBody,:ResponseBody,:ErrorMessage,:ErrorStack,:CreateTime) ";
await _.ExecuteAsync(detailSql, detail);
}, "请求数据保存失败");
}
}
public Request(Type t)
{
type = t;
id = 0;
detail = null;
}
public Task Write(IRequestInfo requestInfo, IRequestDetail requestDetail)
{
_deferFlushCollection.Flush(requestInfo as HttpReports.Collector.Grpc.RequestInfo, requestDetail as HttpReports.Collector.Grpc.RequestDetail);
return(Task.CompletedTask);
}
public Request(Type t, IRequestDetail d)
{
type = t;
id = 0;
detail = d;
}
public RequestBag(IRequestInfo info, IRequestDetail detail)
{
this.RequestInfo = info;
this.RequestDetail = detail;
}
public void Write(IRequestInfo requestInfo, IRequestDetail requestDetail)
{
Storage.AddRequestInfoAsync(requestInfo, requestDetail).ConfigureAwait(false);
}
public Task Write(IRequestInfo requestInfo, IRequestDetail requestDetail)
{
Storage.AddRequestInfoAsync(requestInfo, requestDetail).ConfigureAwait(false);
return(Task.CompletedTask);
}
public RequestDetailsController(IRequestDetail IRequestDetail)
{
_IRequestDetail = IRequestDetail;
}
private IRequestDetail ParseRequestDetail(IRequestDetail request)
{
if (request.Scheme == null)
{
request.Scheme = string.Empty;
}
if (request.Scheme == null)
{
request.Scheme = string.Empty;
}
if (request.QueryString == null)
{
request.QueryString = string.Empty;
}
if (request.Header == null)
{
request.Header = string.Empty;
}
if (request.Cookie == null)
{
request.Cookie = string.Empty;
}
if (request.RequestBody == null)
{
request.RequestBody = string.Empty;
}
if (request.ResponseBody == null)
{
request.ResponseBody = string.Empty;
}
if (request.ErrorMessage == null)
{
request.ErrorMessage = string.Empty;
}
if (request.ErrorStack == null)
{
request.ErrorStack = string.Empty;
}
int max = BasicConfig.HttpReportsFieldMaxLength;
if (request.QueryString.Length > max)
{
request.QueryString = request.QueryString.Substring(0, max);
}
if (request.Header.Length > max)
{
request.Header = request.Header.Substring(0, max);
}
if (request.Cookie.Length > max)
{
request.Cookie = request.Cookie.Substring(0, max);
}
if (request.RequestBody.Length > max)
{
request.RequestBody = request.RequestBody.Substring(0, max);
}
if (request.ResponseBody.Length > max)
{
request.ResponseBody = request.ResponseBody.Substring(0, max);
}
if (request.ErrorMessage.Length > max)
{
request.ErrorMessage = request.ErrorMessage.Substring(0, max);
}
if (request.ErrorStack.Length > max)
{
request.ErrorStack = request.ErrorStack.Substring(0, max);
}
return(request);
}
public void Write(IRequestInfo requestInfo, IRequestDetail requestDetail)
{
_deferFlushCollection.Push(requestInfo as HttpReports.Collector.Grpc.RequestInfo, requestDetail as HttpReports.Collector.Grpc.RequestDetail);
}
private IRequestDetail GetRequestDetail(HttpContext context, IRequestInfo request)
{
IRequestDetail model = ModelCreator.CreateRequestDetail();
if (context.Request != null)
{
model.Id = context.GetUniqueId();
model.RequestId = request.Id;
Dictionary <string, string> cookies = context.Request.Cookies.ToList().ToDictionary(x => x.Key, x => x.Value);
if (cookies != null && cookies.Count > 0)
{
model.Cookie = JsonConvert.SerializeObject(cookies);
}
Dictionary <string, string> headers = context.Request.Headers.ToList().ToDictionary(x => x.Key, x => x.Value.ToString());
if (headers != null && headers.Count > 0)
{
model.Header = JsonConvert.SerializeObject(headers);
}
if (context.Items.ContainsKey(BasicConfig.HttpReportsGlobalException))
{
Exception ex = context.Items[BasicConfig.HttpReportsGlobalException] as Exception;
if (ex != null)
{
model.ErrorMessage = ex.Message;
model.ErrorStack = ex.StackTrace;
}
context.Items.Remove(BasicConfig.HttpReportsGlobalException);
}
if (context.Items.ContainsKey(BasicConfig.HttpReportsRequestBody))
{
string requestBody = context.Items[BasicConfig.HttpReportsRequestBody] as string;
if (requestBody != null)
{
model.RequestBody = requestBody;
}
context.Items.Remove(BasicConfig.HttpReportsRequestBody);
}
if (context.Items.ContainsKey(BasicConfig.HttpReportsResponseBody))
{
string responseBody = context.Items[BasicConfig.HttpReportsResponseBody] as string;
if (responseBody != null)
{
model.ResponseBody = responseBody;
}
context.Items.Remove(BasicConfig.HttpReportsResponseBody);
}
model.CreateTime = context.Items[BasicConfig.ActiveTraceCreateTime].ToDateTime();
model.Scheme = context.Request.Scheme;
model.QueryString = context.Request.QueryString.Value;
}
return(model);
}
public Request(Type t, int i)
{
type = t;
id = i;
detail = null;
}
