public void JsonTest3()
{
List <RequestBag> bags = new List <RequestBag>();
bags.Add(new RequestBag(new Core.Models.RequestInfo
{
Service = "11",
Instance = "1111",
CreateTime = DateTime.Now
}, new Core.Models.RequestDetail
{
QueryString = "11111111",
CreateTime = DateTime.Now
}));
bags.Add(new RequestBag(new Core.Models.RequestInfo
{
Service = "22",
Instance = "2222",
CreateTime = DateTime.Now
}, new Core.Models.RequestDetail
{
QueryString = "2222222",
CreateTime = DateTime.Now
}));
RequestInfoPack ccc = new RequestInfoPack();
var str3 = JsonSerializer.Serialize(bags);
var pack = JsonSerializer.Deserialize <RequestInfoPack>(str3);
}
private async Task Push(List <RequestBag> list, CancellationToken token)
{
try
{
var pack = new RequestInfoPack();
foreach (var x in list)
{
var value = new RequestInfoWithDetail();
value.RequestInfo = new Collector.Grpc.RequestInfo {
Id = x.RequestInfo.Id,
ParentId = x.RequestInfo.ParentId,
Service = x.RequestInfo.Service,
ParentService = x.RequestInfo.ParentService,
Instance = x.RequestInfo.Instance,
Route = x.RequestInfo.Route,
Url = x.RequestInfo.Url,
RequestType = x.RequestInfo.RequestType,
Method = x.RequestInfo.Method,
Milliseconds = x.RequestInfo.Milliseconds,
StatusCode = x.RequestInfo.StatusCode,
RemoteIP = x.RequestInfo.RemoteIP,
LoginUser = x.RequestInfo.LoginUser,
CreateTime = x.RequestInfo.CreateTime,
CreateTimeStamp = x.RequestInfo.CreateTime.Ticks
};
value.RequestDetail = new Collector.Grpc.RequestDetail {
Id = x.RequestDetail.Id,
RequestId = x.RequestDetail.RequestId,
Scheme = x.RequestDetail.Scheme,
QueryString = x.RequestDetail.QueryString,
Header = x.RequestDetail.Header,
Cookie = x.RequestDetail.Cookie,
RequestBody = x.RequestDetail.RequestBody,
ResponseBody = x.RequestDetail.ResponseBody,
ErrorMessage = x.RequestDetail.ErrorMessage,
ErrorStack = x.RequestDetail.ErrorStack,
CreateTime = x.RequestDetail.CreateTime,
CreateTimeStamp = x.RequestDetail.CreateTime.Ticks
};
pack.Data.Add(value);
}
var reply = await _client.WriteRequestAsync(pack);
}
catch (Exception ex) when(ex is RpcException)
{
_logger.LogWarning($"HttpReports transport failed");
}
catch (Exception ex)
{
_logger.LogWarning($"HttpReports transport failed:{ex.Message}");
}
}
public override async Task <WriteReply> Write(RequestInfoPack request, ServerCallContext context)
{
foreach (var item in request.Data)
{
await Storage.AddRequestInfoAsync(item.Info, item.Detail);
}
return(new WriteReply()
{
Code = 0
});
}
public override async Task <WriteReply> WriteRequest(RequestInfoPack request, ServerCallContext context)
{
foreach (var item in request.Data)
{
var info = new Core.Models.RequestInfo {
Id = item.RequestInfo.Id,
Service = item.RequestInfo.Service,
Instance = item.RequestInfo.Instance,
CreateTime = new System.DateTime(item.RequestInfo.CreateTimeStamp),
LoginUser = item.RequestInfo.LoginUser,
Method = item.RequestInfo.Method,
Milliseconds = item.RequestInfo.Milliseconds,
ParentId = item.RequestInfo.ParentId,
ParentService = item.RequestInfo.ParentService,
RemoteIP = item.RequestInfo.RemoteIP,
RequestType = item.RequestInfo.RequestType,
Route = item.RequestInfo.Route,
StatusCode = item.RequestInfo.StatusCode,
Url = item.RequestInfo.Url
};
var detail = new Core.Models.RequestDetail {
Id = item.RequestDetail.Id,
RequestId = item.RequestDetail.RequestId,
Cookie = item.RequestDetail.Cookie,
CreateTime = new System.DateTime(item.RequestDetail.CreateTimeStamp),
ErrorMessage = item.RequestDetail.ErrorMessage,
ErrorStack = item.RequestDetail.ErrorStack,
Header = item.RequestDetail.Header,
QueryString = item.RequestDetail.QueryString,
RequestBody = item.RequestDetail.RequestBody,
ResponseBody = item.RequestDetail.ResponseBody,
Scheme = item.RequestDetail.Scheme
};
RequestBag bag = new RequestBag(info, detail);
await _storage.AddRequestInfoAsync(bag);
}
return(new WriteReply()
{
Code = 0
});
}
private async Task Push(List <Collector.Grpc.RequestInfoWithDetail> list, CancellationToken token)
{
try
{
var pack = new RequestInfoPack();
var data = list.Select(m => new RequestInfoWithDetail()
{
Info = m.Info, Detail = m.Detail
}).ToArray();
pack.Data.AddRange(data);
var reply = await _client.WriteAsync(pack);
}
catch (Exception ex)
{
//TODO ReTry?
_logger.LogError(ex, "ReportsTransport Error");
}
}
