/// <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); }