/// <summary>
/// Update a monitor message from HttpClient
/// </summary>
/// <param name="message"></param>
/// <param name="response"></param>
/// <param name="ex"></param>
/// <returns></returns>
public static async Task UpdateForHttpClient(MonitorMessage message, HttpResponseMessage response, Exception ex = null)
{
message.EndTime = DateTimeOffset.UtcNow;
message.Duration = message.EndTime - message.StartTime;
if (response != null)
{
message.ResponseBody = await GetContent(response);
message.ResponseHeaders = GetHeaders(response.Headers);
message.ResponseArchitectureMetadata = GetArchitectureMetadata(response.Headers);
message.ResponseCode = ((int)response.StatusCode).ToString();
message.IsError = (int)response.StatusCode < 200 || (int)response.StatusCode >= 300;
}
if (ex != null)
{
if (!ProcessShouldSkipException(ex, message))
{
message.IsError = true;
message.ErrorMessage = MonitorHelper.GetErrorString(ex);
if (String.IsNullOrEmpty(message.ResponseCode))
{
message.ResponseCode = "ERROR";
}
}
}
}
public Task OnMessage(Message theMessage)
{
Task returnTask;
try {
SyntheticMessageProcessor processor = new SyntheticMessageProcessor(_connectionString, _monitoringTopic, _logger);
Task messageTask = processor.OnMessage(theMessage);
returnTask = Task.WhenAll(new Task[] { messageTask });
} catch (MonitoringException mex) {
_logger.LogError($"ERROR - {mex.Message} {mex.StackTrace}");
returnTask = Task.FromException(mex);
} catch (Exception ex) {
_logger.LogWarning($"Error scenario found in monitored service - {ex.Message}");
string dataJSON = Encoding.UTF8.GetString(theMessage.Body);
MonitorMessage errorMessage = JsonConvert.DeserializeObject <MonitorMessage>(dataJSON);
errorMessage.AssociatedId = $"{errorMessage.AssociatedId}_DLQ";
if (ts is null)
{
ts = new SessionlessTopicSender(_connectionString, _monitoringTopic);
}
Task sendTask = ts.Send(JsonConvert.SerializeObject(errorMessage), theMessage.UserProperties["CollectionId"].ToString(), theMessage.UserProperties["Context"].ToString(), DateTime.MinValue, "SYNTHETIC_ERROR");
returnTask = Task.WhenAll(new Task[] { sendTask });
}
return(returnTask);
}
public int c; //用于改变最大显示点数
//请求订阅
private void cedaManagaer_OnCedaMessage(Message obj)
{
CedaObject co = CedaObject.ToCedaObject(obj);
MonitorMessage ts = MsgHelper.Deserialize <MonitorMessage>(co.MessageBody, MsgSerializerType.Json);
string key = ts.type;
DateTime dt = zedgraphHelper.stringToDateTime(ts.date + " " + ts.time);
XDate xd = new XDate(dt);
double d = Convert.ToDouble(ts.amount);
if (d != 0)
{
PointPair pointPair = new PointPair((double)xd, d);
addPointData(key, pointPair);
if (pointData.getPointPairListByKey(key).Count <= 0)
{
this.createLines();
}
if (pointData.getPointPairListByKey(key).Count > c)
{
pointData.getPointPairListByKey(key).RemoveRange(0, pointData.getPointPairListByKey(key).Count - c);
this.refreshPane();
}
else
{
this.refreshPane();
}
}
}
/// <summary>
/// Update a monitor message from HttpContext
/// </summary>
/// <param name="message"></param>
/// <param name="httpContext"></param>
/// <param name="ex"></param>
/// <returns></returns>
public static async Task UpdateForHttpRequest(MonitorMessage message, HttpContext httpContext, Exception ex = null)
{
message.EndTime = DateTimeOffset.UtcNow;
message.Duration = message.EndTime - message.StartTime;
var response = httpContext.Response;
message.ResponseBody = await GetContent(response);
message.ResponseHeaders = GetHeaders(response.Headers);
message.ResponseArchitectureMetadata = GetCurrentArchitectureMetadata(httpContext);
message.ResponseCode = response.StatusCode.ToString();
if (ex == null)
{
message.IsError = response.StatusCode < 200 || response.StatusCode >= 300;
}
else
{
if (!ProcessShouldSkipException(ex, message))
{
message.IsError = true;
message.ErrorMessage = MonitorHelper.GetErrorString(ex);
if (response.StatusCode == 200)
{
message.ResponseCode = "500";
}
}
}
}
/// <summary>
/// Update a monitor message from a service bus sender message
/// </summary>
/// <param name="message"></param>
/// <param name="ex"></param>
/// <returns></returns>
public static async Task UpdateForServiceBusMessageSender(MonitorMessage message, Exception ex = null)
{
message.EndTime = DateTimeOffset.UtcNow;
message.Duration = message.EndTime - message.StartTime;
if (ex != null)
{
if (!ProcessShouldSkipException(ex, message))
{
message.IsError = true;
message.ErrorMessage = MonitorHelper.GetErrorString(ex);
if (String.IsNullOrEmpty(message.ResponseCode))
{
message.ResponseCode = "ERROR";
}
}
}
else
{
if (String.IsNullOrEmpty(message.ResponseCode))
{
message.ResponseCode = "SUCCESS";
}
}
}
private void cedaClient_OnCedaMessage(Message obj)
{
CedaObject co = CedaObject.ToCedaObject(obj);
MonitorMessage ts = MsgHelper.Deserialize <MonitorMessage>(co.MessageBody, MsgSerializerType.Json);
string key = ts.MKey;
if (string.IsNullOrEmpty(ts.MUpdatetime))
{
return;
}
DateTime dt = zedgraphHelper.stringToDateTime(ts.MUpdatetime);
XDate xd = new XDate(dt);
//XDate xd = new XDate(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second);
//xd.AddSeconds((double)dt.Second);
PointPair pointPair = new PointPair((double)xd, (double)ts.MValue);
if (pointData.isContain(key))
{
addPointData(key, pointPair);
//this.refreshPane();
}
}
public static bool ProcessShouldSkipException(Exception ex, MonitorMessage message)
{
if (ex is MonitorShouldSkipException)
{
UpdateShouldSkipMessage(message);
return(true);
}
else
{
return(false);
}
}
//设置点的组合，以键值对的形式
private PointPair setPointPair(MonitorMessage st)
{
if (string.IsNullOrEmpty(st.time))
{
return(null);
}
else
{
DateTime dt = zedgraphHelper.stringToDateTime(st.time);
XDate xd = new XDate(dt);
double d = Convert.ToDouble(st.amount);
return(new PointPair((double)xd, (double)d));
}
}
/// <summary>
///
/// </summary>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="time"></param>
/// <param name="queryParams"></param>
/// <param name="requesHead"></param>
/// <param name="httpMethod"></param>
public static void LogInfo(DateTime startTime, DateTime endTime, string time, string queryParams, string requesHead, string httpMethod)
{
MonitorMessage logMessage = new MonitorMessage()
{
//Url = RequestHelper.GetRawUrl(),
StartTime = startTime,
EndTime = endTime,
Time = time,
QueryParams = queryParams,
RequesHead = requesHead,
HttpMethod = httpMethod,
IP = IPHelper.GetWebClientIp(),
};
WriteLog(logMessage);
}
public override Task <string> ProcessMessage(Message messageAsObject, string messageAsUTF8)
{
Task <string> returnTask;
try {
MonitorMessage monitoredMessage = JsonConvert.DeserializeObject <MonitorMessage>(messageAsUTF8);
monitoredMessage.AssociatedId = messageAsObject.MessageId;
returnTask = Task.FromResult(JsonConvert.SerializeObject(monitoredMessage));
} catch (Exception ex) {
ApplicationException exp = new ApplicationException($"ERROR in synthetic monitoring service - unable to process synthetic message caused by {ex.Message}");
_logger.LogError($"Failed to process synthetic message - {ex.Message} {ex.StackTrace}");
throw exp;
}
return(returnTask);
}
public void Execute(IJobExecutionContext context)
{
var monitorMessage = new MonitorMessage
{
InstanceName = instanceName,
ModuleName = "Helloworld",
CreateTime = DateTime.Now,
NextFireTime = context.NextFireTimeUtc.HasValue ?
context.NextFireTimeUtc.Value.DateTime.ToLocalTime() :
(DateTime?)null
};
mqHandler.Send(monitorMessage);
Console.WriteLine("[{0:yyyy-MM-dd HH:mm:ss.ffff}] Send: {1}",
DateTime.Now,
monitorMessage.Message);
}
/// <summary>
/// Create a monitor message for a generic object
/// </summary>
/// <param name="httpContext"></param>
/// <param name="obj"></param>
/// <param name="requestAddress"></param>
/// <param name="requestMethod"></param>
/// <returns></returns>
public static async Task <MonitorMessage> CreateForGenericObject(HttpContext httpContext, object obj, string requestAddress, string requestMethod = "SEND")
{
var message = new MonitorMessage();
message.MessageType = MonitorMessageTypes.GenericObjectSender;
message.CallType = message.MessageType.ToString();
var request = httpContext.Request;
message.CorrelationId = GetCurrentCorrelationId(httpContext);
message.RequestAddress = requestAddress;
message.RequestBody = await GetContentFromObject(obj);
//message.RequestHeaders = GetHeaders(request.Headers);
message.RequestArchitectureMetadata = GetCurrentArchitectureMetadata(httpContext);
message.RequestMethod = requestMethod;
return(message);
}
/// <summary>
/// Create a monitor message from a service bus sender message
/// </summary>
/// <param name="messageSender"></param>
/// <param name="serviceBusMessage"></param>
/// <returns></returns>
public static async Task <MonitorMessage> CreateForServiceBusMessageSender(ISenderClient messageSender, Message serviceBusMessage)
{
var message = new MonitorMessage();
message.MessageType = MonitorMessageTypes.ServiceBusSender;
message.CallType = message.MessageType.ToString();
message.CorrelationId = GetCurrentCorrelationId(serviceBusMessage);
message.RequestAddress = messageSender.ServiceBusConnection.Endpoint.OriginalString + "/" + messageSender.Path;
message.RequestBody = await GetContent(serviceBusMessage.Body);
message.RequestArchitectureMetadata = GetArchitectureMetadata(serviceBusMessage.UserProperties);
message.RequestHeaders = GetHeaders(serviceBusMessage.UserProperties);
message.RequestMethod = "SEND";
return(message);
}
public Task Create(string monitoredServiceName) // NOTE: a subscription with EventType=monitoredServiceName is expected
{
Task returnTask;
try {
MonitorMessage msg = new MonitorMessage {
MonitoredService = monitoredServiceName
};
Task sendTask = ts.Send(JsonConvert.SerializeObject(msg), Guid.NewGuid().ToString("D"), "SYNTHETIC_MONITORING", DateTime.MinValue, msg.MonitoredService);
returnTask = Task.WhenAll(new Task[] { sendTask });
} catch (Exception ex) {
_logger.LogError($"ERROR starting synthetic transaction - {ex.Message}");
returnTask = Task.FromException(ex);
}
return(returnTask);
}
private static void SerializationTest2(string[] args)
{
using (new MPI.Environment(ref args))
{
Intracommunicator comm = Communicator.world;
if (comm.Rank == 0)
{
var test = new MonitorMessage <ProdConsInternals <int> >()
{
InternalState = new ProdConsInternals <int>()
{
N = 100,
Full = new ConditionalVar()
{
WaitingQueue = new List <int>()
{
1
}
},
Empty = new ConditionalVar()
{
WaitingQueue = new List <int>()
{
2
}
}
},
LastCsEntrySyncNumber = 0,
};
Request req = comm.ImmediateSend(test, 1, 0);
req.Test();
}
else
{
MonitorMessage <ProdConsInternals <int> > msg = comm.Receive <MonitorMessage <ProdConsInternals <int> > >
(Communicator.anySource, Communicator.anyTag);
Console.WriteLine(string.Format("#{0} received message [{1}]",
comm.Rank, msg.InternalState.Full.WaitingQueue.First()));
}
}
}
/// <summary>
/// Create a monitor message from HttpContext
/// </summary>
/// <param name="httpContext"></param>
/// <returns></returns>
public static async Task <MonitorMessage> CreateForHttpRequest(HttpContext httpContext)
{
var message = new MonitorMessage();
message.MessageType = MonitorMessageTypes.HttpRequest;
message.CallType = message.MessageType.ToString();
var request = httpContext.Request;
message.CorrelationId = GetCurrentCorrelationId(httpContext);
message.RequestAddress = UriHelper.GetDisplayUrl(request);
message.RequestBody = await GetContent(request);
message.RequestHeaders = GetHeaders(request.Headers);
message.RequestArchitectureMetadata = httpContext.GetRequestArchitectureMetadata();
message.RequestMethod = request.Method;
message.RequestUser = GetRequestUser(httpContext);
return(message);
}
/// <summary>
/// Update a monitor message from a generic object
/// </summary>
/// <param name="message"></param>
/// <param name="ex"></param>
/// <returns></returns>
public static async Task UpdateForGenericObject(MonitorMessage message, Exception ex)
{
message.EndTime = DateTimeOffset.UtcNow;
message.Duration = message.EndTime - message.StartTime;
if (ex != null)
{
if (!ProcessShouldSkipException(ex, message))
{
message.IsError = true;
message.ErrorMessage = MonitorHelper.GetErrorString(ex);
message.ResponseCode = "ERROR";
}
}
else
{
message.ResponseCode = "SUCCESS";
}
}
public Task OnMessage(Message theMessage, string slackWebhookToSendAlert, string slackChannelToSendAlert)
{
Task returnTask;
try {
string dataJSON = Encoding.UTF8.GetString(theMessage.Body);
MonitorMessage msg = JsonConvert.DeserializeObject <MonitorMessage>(dataJSON);
_logger.LogWarning($"Error scenario found on {msg.MonitoredService} service");
StringBuilder sb = new StringBuilder();
sb.AppendLine($"*:warning: Infrastructure Problem Detected*");
sb.AppendLine($"_{msg.MonitoredService}_");
sb.Append($"_{msg.StartTime}_");
SlackSender connector = new SlackSender(slackWebhookToSendAlert, slackChannelToSendAlert);
returnTask = connector.GetJSONResponse(sb.ToString());
} catch (Exception ex) {
_logger.LogError($"ERROR - {ex.Message} {ex.StackTrace}");
returnTask = Task.FromException(ex);
}
return(returnTask);
}
/// <summary>
/// 写入日志统一入口
/// </summary>
/// <param name="msgLog"></param>
private static void WriteLog(MonitorMessage msgLog)
{
Logger.ApiMonitorInfo(msgLog);
}
public static void UpdateShouldSkipMessage(MonitorMessage message)
{
message.ResponseCode = "SKIPPED";
}
/// <summary>
/// Update a monitor message from a generic object
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public static async Task UpdateForGenericObject(MonitorMessage message)
{
await UpdateForGenericObject(message, null);
}
