public static bool IsValidateGetMetrics(MonitoringRequest monitoringRequest, out string Message)
{
if (!MonitoringConstants.NameSpace.Any(x => x.Equals(monitoringRequest.NameSpace)))
{
Message = $"Invalid namespace:{monitoringRequest.NameSpace}, Please provide a proper namespace; It should be {String.Join(",", MonitoringConstants.NameSpace.ToList())}";
return(false);
}
if (!MonitoringConstants.Ec2Metrics.Any(x => x.Equals(monitoringRequest.Metrics)))
{
Message = $"Invalid Metrics value:{monitoringRequest.Metrics}, it should be {String.Join(",", MonitoringConstants.Ec2Metrics)}";
return(false);
}
Message = "Request is valid";
return(true);
}
public async Task <IActionResult> GetMetrics([FromBody] MonitoringRequest monitoringRequest, [FromQuery] string MetricType)
{
if (!ValidationHelper.IsValidMonitorRequest(monitoringRequest, MetricType, out string message))
{
return(BadRequest(new { Message = message }));
}
var metrics = await monitoringOperations.GetMetrics(monitoringRequest.Region, monitoringRequest.NameSpace, monitoringRequest.Metrics);
var filterMetrics = metrics.Where(x => monitoringRequest.ResourceIds.Any(y => x.Dimensions.Any(z => z.Value.Equals(y)))).ToList();
var response = await monitoringOperations.GetMetricsData(monitoringRequest, filterMetrics);
var mapResponse = monitoringOperations.MapResponse(response.MetricResponse, MetricType, monitoringRequest.Limit);
return(Ok(mapResponse));
}
public static bool IsValidMonitorRequest(MonitoringRequest monitoringRequest, string MetricType, out string Message)
{
if (monitoringRequest.ResourceIds == null || !monitoringRequest.ResourceIds.Any())
{
Message = $"There is no ResourceId corresponding to the metrics";
return(false);
}
DateTime temp;
if (monitoringRequest.IsDateCustom)
{
if (!DateTime.TryParse(monitoringRequest.StartDateTime.ToString(), out temp))
{
Message = $"Invalid Start Date:{monitoringRequest.StartDateTime.ToString()}";
return(false);
}
if (!DateTime.TryParse(monitoringRequest.EndDateTime.ToString(), out temp))
{
Message = $"Invalid End Date:{monitoringRequest.EndDateTime.ToString()}";
return(false);
}
}
else
{
if (monitoringRequest.RelativeMinutes <= 0)
{
Message = $"Invalid relative time:{monitoringRequest.RelativeMinutes}";
return(false);
}
}
if (!MonitoringConstants.MetricType.Any(x => x.Equals(MetricType)))
{
Message = $"Invalid MetricType:{MetricType}, Please enter proper MetricType; It should be {String.Join(",", MonitoringConstants.MetricType.ToList())}";
return(false);
}
if (!MonitoringConstants.NameSpace.Any(x => x.Equals(monitoringRequest.NameSpace)))
{
Message = $"Invalid namespace:{monitoringRequest.NameSpace}, Please provide a proper namespace; It should be {String.Join(",", MonitoringConstants.NameSpace.ToList())}";
return(false);
}
Message = "Request is valid";
return(true);
}
public async Task <MonitoringResponse> GetMetricsData(MonitoringRequest monitoringRequest, List <Metric> metrics)
{
cloudWatchRepository.Region = monitoringRequest.Region;
var metricDataRequest = GenerateMetricRequest(monitoringRequest, metrics);
if (!metricDataRequest.MetricDataQueries.Any())
{
return(new MonitoringResponse()
{
MetricResponse = new List <MonitoritingMetrics>()
});
}
var response = await cloudWatchRepository.GetMetricData(metricDataRequest);
var mapResponse = mapper.Map <List <MonitoritingMetrics> >(response.MetricDataResults);
return(new MonitoringResponse()
{
NextToken = response.NextToken, MetricResponse = mapResponse
});
}
private GetMetricDataRequest GenerateMetricRequest(MonitoringRequest monitoringRequest, List <Metric> metrics)
{
var startDate = DateTime.Now.AddMinutes((-1) * monitoringRequest.RelativeMinutes);
var endDate = DateTime.Now;
if (monitoringRequest.IsDateCustom)
{
startDate = monitoringRequest.StartDateTime.Value;
endDate = monitoringRequest.EndDateTime.Value;
}
var metricQueryCollection = new List <MetricDataQuery>();
int counter = 0;
var period = (int)(Math.Ceiling((endDate - startDate).TotalSeconds / 12) / 60) * 60;
foreach (var metric in metrics)
{
metricQueryCollection.Add(new MetricDataQuery()
{
Id = "m" + counter.ToString(),
MetricStat = new MetricStat()
{
Stat = "Average",
Period = period,
Metric = metric
}
});
counter++;
}
return(new GetMetricDataRequest()
{
NextToken = monitoringRequest.NextToken,
StartTimeUtc = startDate,
EndTimeUtc = endDate,
MetricDataQueries = metricQueryCollection
});
}
private static async Task <MessageCard> CreateMessageCardAsync(
string title, string summary, MonitoringRequest monitoringRequest,
IApplication httpApp, IHttpRequest request,
Func <MessageCard.Section> getRequestInformation)
{
var appName = AppSettings.ApplicationInsights.TeamsAppIdentification
.ConfigurationString(
x => x,
(why) => httpApp.GetType().FullName);
var appImage = AppSettings.ApplicationInsights.TeamsAppImage
.ConfigurationString(
x => new Uri(x),
(why) => default);
var content = await ReadContentAsync();
var utcOffset = "Central Standard Time"
.FindSystemTimeZone()
.GetUtcOffset(DateTime.UtcNow);
var sections = new MessageCard.Section[]
{
new MessageCard.Section
{
activityTitle = appName,
activitySubtitle = (DateTime.UtcNow + utcOffset).ToString("f"),
activityImage = appImage,
},
getRequestInformation(),
new MessageCard.Section
{
title = "Headers",
markdown = false, // so that underscores are not stripped
facts = request.Headers
.Select(
header => new MessageCard.Section.Fact
{
name = $"{header.Key}:",
value = header.Value.Join(","),
})
.ToArray(),
},
new MessageCard.Section
{
title = "Content",
text = $"<blockquote>{content}</blockquote>",
}
};
if (request.Properties.ContainsKey(HttpApplication.DiagnosticsLogProperty))
{
var diagnosticsLogs = (string[])request.Properties[HttpApplication.DiagnosticsLogProperty];
sections = sections
.Append(
new MessageCard.Section
{
title = "Log",
text = $"<blockquote>{diagnosticsLogs.Join("<br />")}</blockquote>",
})
.ToArray();
}
if (request.Properties.TryGetValue(EnableProfilingAttribute.ResponseProperty, out object profileObj))
{
var profile = (IProfile)profileObj;
var log = profile.Events
.NullToEmpty()
.OrderBy(kvp => kvp.Key)
.Select(diagEvent => $"<b>{diagEvent.Key}</b>:<i>{diagEvent.Value}</i>")
.Join("<br />");
sections = sections
.Append(
new MessageCard.Section
{
title = "Diagnostics",
text = $"<blockquote>{log}</blockquote>",
})
.ToArray();
}
var postmanLink = new QueryableServer <Api.Azure.Monitoring.MonitoringRequest>(request)
.Where(mr => mr.monitoringRequestRef == monitoringRequest.monitoringRequestRef)
.Where(mr => mr.when == monitoringRequest.when)
.HttpAction(MonitoringRequest.PostmanAction)
.Location()
.SignWithAccessTokenAccount(Guid.NewGuid(), Guid.NewGuid(), DateTime.UtcNow.AddYears(1),
url => url);
var message = new MessageCard
{
summary = summary,
themeColor = "F00807",
title = title,
sections = sections,
potentialAction = new MessageCard.ActionCard[]
{
new MessageCard.ActionCard
{
name = "Postman",
type = "OpenUri",
targets = new MessageCard.ActionCard.Target[]
{
new MessageCard.ActionCard.Target
{
os = "default",
uri = postmanLink,
}
}
},
new MessageCard.ActionCard
{
name = "Application Insights",
type = "OpenUri",
targets = new MessageCard.ActionCard.Target[]
{
new MessageCard.ActionCard.Target
{
os = "default",
uri = new Uri("https://www.example.com/ai/message/1234"),
}
}
},
new MessageCard.ActionCard
{
type = "ActionCard",
name = "Run in TestFramework",
inputs = new MessageCard.ActionCard.Input[]
{
new MessageCard.ActionCard.Input
{
type = "TextInput",
id = "comment",
title = "Test ID",
isMultiline = false,
},
new MessageCard.ActionCard.Input
{
type = "MultichoiceInput",
id = "move",
title = "Pick a test function",
choices = new MessageCard.ActionCard.Input.Choice []
{
new MessageCard.ActionCard.Input.Choice
{
display = "Unauthenticated",
value = "unauthenticated",
},
new MessageCard.ActionCard.Input.Choice
{
display = "Physicial Redirect",
value = "redirect",
},
new MessageCard.ActionCard.Input.Choice
{
display = "Session Authenticated",
value = "session",
},
new MessageCard.ActionCard.Input.Choice
{
display = "Account Authenticated",
value = "account",
},
},
}
}
},
}
};
return(message);
async Task <string> ReadContentAsync()
{
if (!request.HasBody)
{
return(string.Empty);
}
try
{
if (request.RequestHeaders.ContentType.IsTextType())
{
return(await request.ReadContentAsStringAsync());
}
var byteContent = await request.ReadContentAsync();
return(byteContent.ToBase64String());
}
catch (Exception)
{
return(string.Empty);
}
}
}
