/// <summary> /// Report how long something took to happen and this type of metric will calculate the average time it takes /// </summary> /// <param name="category">Category of the metric</param> /// <param name="metricName">Name of the metric</param> /// <param name="timeTaken">How long the event being tracked took</param> public static void Time(string category, string metricName, TimeSpan timeTaken) { MetricClient.QueueMetric(new Metric(category, metricName, MetricType.CounterTime) { Value = timeTaken.TotalSeconds }); }
public async Task WhenSendingMetricQueryThenTheResultsAreAsExpected() { // Authenticate (set real values in resourceIdentifier to run this test). var authenticationServices = new AuthenticationServices(); await authenticationServices.AuthenticateUserAsync(); ICredentialsFactory credentialsFactory = new ActiveDirectoryCredentialsFactory(authenticationServices); var resourceId = $"/subscriptions/{this.resourceIdentifier.SubscriptionId}/resourceGroups/{this.resourceIdentifier.ResourceGroupName}/providers/Microsoft.Storage/storageAccounts/{this.resourceIdentifier.ResourceName}/queueServices/default"; MetricClient client = new MetricClient(this.tracerMock.Object, credentialsFactory); var parameters = new QueryParameters() { StartTime = DateTime.UtcNow.Date.AddDays(-1), EndTime = DateTime.UtcNow.Date, Aggregations = new List <Aggregation> { Aggregation.Total }, MetricNames = new List <string>() { "QueueMessageCount" }, Interval = TimeSpan.FromMinutes(60) }; var metrics1 = (await client.GetResourceMetricsAsync(resourceId, parameters)).ToList(); var metrics2 = (await client.GetResourceMetricsAsync(this.resourceIdentifier, StorageServiceType.Queue, parameters)).ToList(); Assert.IsTrue(metrics1.Any() && metrics2.Any(), "Lists are not full with data"); Assert.IsTrue(metrics1.First().Timeseries.Any() && metrics2.First().Timeseries.Any(), "Metrics do not contain Time series"); Assert.IsTrue(metrics1[0].Timeseries[0].Data.Any() && metrics2[0].Timeseries[0].Data.Any(), "Time series are not full with data"); }
public async Task WhenSubjectAndKeyContainRestrictedCharacters_GetIndividualBySubject_UrlEncodesRestrictedCharacters() { // Setup mock expectation for a encoded url call var mockHttpHandler = new MockHttpMessageHandler(); var response = @"{ 'id': 'ca98dfajl3kja9kjh34589734', 'applicationId': 'ci123doiu3', 'key': 'testKey 123', 'subject': 'test:subject=123', 'value': 5 }" .Replace("'", "\""); mockHttpHandler.Expect(HttpMethod.Get, "https://api.useast1.badgeup.io/v2/apps/1337/metrics/test%3Asubject%3D123/testKey%20123").Respond("application/json", response); using (var badgeUpClient = new BadgeUpHttpClient(ApiKey.Create("eyJhY2NvdW50SWQiOiJ0aGViZXN0IiwiYXBwbGljYXRpb25JZCI6IjEzMzciLCJrZXkiOiJpY2VjcmVhbWFuZGNvb2tpZXN5dW0ifQ=="), "https://api.useast1.badgeup.io")) { badgeUpClient.SetHttpClient(mockHttpHandler.ToHttpClient()); // pass subject and key with restricted characters var metricClient = new MetricClient(badgeUpClient); var metric = await metricClient.GetIndividualBySubject("test:subject=123", "testKey 123"); Assert.Equal("test:subject=123", metric.Subject); Assert.Equal("testKey 123", metric.Key); } // expect encoded url to have been called mockHttpHandler.VerifyNoOutstandingExpectation(); }
public async Task WhenCallingGetResourceMetricsWithNamespaceHappyFlow() { string expectedUri = "/subscriptions/SUBSCRIPTION_ID/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/STORAGE_NAME/queueServices/default"; var azureResponse = new AzureOperationResponse <ResponseInner>() { Body = new ResponseInner("timespan", GetMetricList()), Request = new HttpRequestMessage(), RequestId = "RequestId", Response = new HttpResponseMessage() }; this.metricsOperationsMock .Setup(metric => metric.ListWithHttpMessagesAsync(It.IsAny <string>(), It.IsAny <ODataQuery <MetadataValueInner> >(), It.IsAny <string>(), It.IsAny <TimeSpan?>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <ResultType?>(), It.IsAny <string>(), It.IsAny <Dictionary <string, List <string> > >(), It.IsAny <CancellationToken>())) .ReturnsAsync(azureResponse); this.monitorManagementClientMock.SetupGet(monitorClient => monitorClient.Metrics).Returns(this.metricsOperationsMock.Object); IMetricClient metricClient = new MetricClient(this.tracerMock.Object, this.monitorManagementClientMock.Object); List <MetricQueryResult> metrics = (await metricClient.GetResourceMetricsAsync(this.resourceIdentifier, StorageServiceType.Queue, new QueryParameters() { MetricNamespace = "NAMESPACE" }, default(CancellationToken))).ToList(); // Validate that right Uri was generated this.metricsOperationsMock.Verify(metric => metric.ListWithHttpMessagesAsync(expectedUri, It.IsAny <ODataQuery <MetadataValueInner> >(), null, null, string.Empty, null, null, null, null, "NAMESPACE", null, CancellationToken.None)); Assert.AreEqual(metrics.Count, 2, "2 metrics are expected"); }
/// <summary> /// Flushes any items in the queue when shutting down an app /// </summary> public static void Shutdown() { //flush logs queue _LogClient.Close(); //flush any remaining metrics as well MetricClient.StopMetricsQueue("Logger Shutdown called"); }
/// <summary> /// Sums up the values passed in and reports the total once per minute /// </summary> /// <param name="category">Category of the metric</param> /// <param name="metricName">Name of the metric</param> /// <param name="value"></param> public static void Sum(string category, string metricName, double value, MetricSetting advancedSettings = null) { var m = new Metric(category, metricName, MetricType.Counter); m.Value = value; m.Settings = advancedSettings; MetricClient.QueueMetric(m); }
/// <summary> /// Sums up the values passed in and reports the average of the values once per minute /// </summary> /// <param name="category">Category of the metric</param> /// <param name="metricName">Name of the metric</param> /// <param name="value"></param> public static void Average(string category, string metricName, double value, MetricSetting advancedSettings = null) { var m = new Metric(category, metricName, MetricType.MetricAverage) { Value = value, Settings = advancedSettings }; MetricClient.QueueMetric(m); }
static StackifyTraceListener() { GlobalEventSystemFacade.SubscribeToPrepareForShutDownEvent(args => { StackifyAPILogger.Log("Composite C1 TraceListener shutting down"); MetricClient.StopMetricsQueue("Composite C1 TraceListener shutting down"); StackifyLogger.Shutdown(); }); }
public async Task WhenSubjectAndKeyContainRestrictedCharacters_GetAllBySubject_UrlEncodesRestrictedCharacters() { // Setup mock expectation for a encoded url call var mockHttpHandler = new MockHttpMessageHandler(); var response = @"{ 'pages': { 'previous': null, 'next': null }, 'data': [ { 'id': 'cja8a0980j3jkajhaaa345810', 'applicationId': 'e7kmr6m0ob', 'key': 'test', 'subject': 'test:subject=123', 'value': 5 }, { 'id': 'cjmx29083hjkaaa325usgaitx', 'applicationId': 'e7kmr6m0ob', 'key': 'test:key', 'subject': 'test:subject=123', 'value': 1 }, { 'id': 'cjmy215tq87hdo1b9hrb2qlsj', 'applicationId': 'e7kmr6m0ob', 'key': 'test:metric', 'subject': 'test:subject=123', 'value': 5 } ] }" .Replace("'", "\""); mockHttpHandler.Expect(HttpMethod.Get, "https://api.useast1.badgeup.io/v2/apps/1337/metrics/test%3Asubject%3D123").Respond("application/json", response); using (var badgeUpClient = new BadgeUpHttpClient(ApiKey.Create("eyJhY2NvdW50SWQiOiJ0aGViZXN0IiwiYXBwbGljYXRpb25JZCI6IjEzMzciLCJrZXkiOiJpY2VjcmVhbWFuZGNvb2tpZXN5dW0ifQ=="), "https://api.useast1.badgeup.io")) { badgeUpClient.SetHttpClient(mockHttpHandler.ToHttpClient()); // pass subject and key with restricted characters var metricClient = new MetricClient(badgeUpClient); var metrics = await metricClient.GetAllBySubject("test:subject=123"); Assert.Equal(3, metrics.Count); Assert.Equal("test:subject=123", metrics[0].Subject); Assert.Equal("test:subject=123", metrics[1].Subject); Assert.Equal("test:subject=123", metrics[2].Subject); Assert.Equal("test", metrics[0].Key); Assert.Equal("test:key", metrics[1].Key); Assert.Equal("test:metric", metrics[2].Key); } // expect encoded url to have been called mockHttpHandler.VerifyNoOutstandingExpectation(); }
/// <summary> /// Guage type metric that reports the last value reported once a minute /// </summary> /// <param name="category">Category of the metric</param> /// <param name="metricName">Name of the metric</param> /// <param name="value">Explicit value to set the metric to</param> /// <param name="autoResendLastValueIfNothingReported">Every minute resend the last value if nothing reported</param> public static void SetGauge(string category, string metricName, double value, bool autoResendLastValueIfNothingReported = false) { var m = new Metric(category, metricName, MetricType.MetricLast) { Value = value, Settings = new MetricSetting { AutoReportLastValueIfNothingReported = autoResendLastValueIfNothingReported } }; MetricClient.QueueMetric(m); }
/// <summary> /// Counts how many times something happens per minute /// </summary> /// <param name="category">Category of the metric</param> /// <param name="metricName">Name of the metric</param> /// <param name="incrementBy"></param> /// <param name="autoSendIfZero">If nothing is reported for a minute, should we report a 0?</param> public static void Count(string category, string metricName, int incrementBy = 1, bool autoReportZeroIfNothingReported = false) { var m = new Metric(category, metricName, MetricType.Counter); m.Value = incrementBy; m.Settings = new MetricSetting { AutoReportZeroIfNothingReported = autoReportZeroIfNothingReported }; MetricClient.QueueMetric(m); }
/// <summary> /// Increment or decrement a guage metric type /// </summary> /// <param name="category">Category of the metric</param> /// <param name="metricName">Name of the metric</param> /// <param name="incrementBy">Value can be positive or negative to decrement. Defaults to 1</param> public static void IncrementGauge(string category, string metricName, double incrementBy, MetricSetting advancedSettings) { //leaving the count as 1 below because when it gets processed later it would sum up the count there var m = new Metric(category, metricName, MetricType.MetricLast); m.Value = incrementBy; m.IsIncrement = true; m.Settings = advancedSettings; MetricClient.QueueMetric(m); }
public async Task WhenCallingGetResourceMetricsWithServiceTypeHappyFlow() { var timestamp = DateTime.UtcNow; string expectedUri = "/subscriptions/SUBSCRIPTION_ID/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/STORAGE_NAME/queueServices/default"; var azureResponse = new AzureOperationResponse <ResponseInner>() { Body = new ResponseInner("timespan", GetMetricList(timestamp)), Request = new HttpRequestMessage(), RequestId = "RequestId", Response = new HttpResponseMessage() }; this.metricsOperationsMock .Setup(metric => metric.ListWithHttpMessagesAsync(It.IsAny <string>(), It.IsAny <ODataQuery <MetadataValueInner> >(), It.IsAny <string>(), It.IsAny <TimeSpan?>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int?>(), It.IsAny <string>(), It.IsAny <ResultType?>(), It.IsAny <string>(), It.IsAny <Dictionary <string, List <string> > >(), It.IsAny <CancellationToken>())) .ReturnsAsync(azureResponse); this.monitorManagementClientMock.SetupGet(monitorClient => monitorClient.Metrics).Returns(this.metricsOperationsMock.Object); IMetricClient metricClient = new MetricClient(this.tracerMock.Object, this.resourceIdentifier.SubscriptionId, this.monitorManagementClientMock.Object); List <MetricQueryResult> metrics = (await metricClient.GetResourceMetricsAsync(this.resourceIdentifier, ServiceType.AzureStorageQueue, new QueryParameters(), default(CancellationToken))).ToList(); // Validate that right Uri was generated this.metricsOperationsMock.Verify(metric => metric.ListWithHttpMessagesAsync(expectedUri, It.IsAny <ODataQuery <MetadataValueInner> >(), null, null, string.Empty, null, null, null, null, null, null, CancellationToken.None)); Assert.AreEqual(metrics.Count, 2, "2 metrics are expected"); // Validate first metric was converted successfully Assert.AreEqual("MetricName1", metrics[0].Name, "First metric name isn't correct"); Assert.AreEqual("ByteSeconds", metrics[0].Unit, "First metric unit isn't correct"); Assert.AreEqual(0, metrics[0].Timeseries.Count, "First metric timeseries should be empty"); // Validate second metric was converted successfully Assert.AreEqual("MetricName2", metrics[1].Name, "Second metric name isn't correct"); Assert.AreEqual("MilliSeconds", metrics[1].Unit, "Second metric unit isn't correct"); Assert.AreEqual(5, metrics[1].Timeseries.Count, "Second metric timeseries should be empty"); Assert.AreEqual(2, metrics[1].Timeseries[0].Data.Count, "Second metric first timeseries (Dimension1Value1) length should be 2"); Assert.AreEqual(2, metrics[1].Timeseries[1].Data.Count, "Second metric second timeseries (Dimension1Value2) length should be 2"); Assert.AreEqual(1.1, metrics[1].Timeseries[0].Data[0].Average, "Second metric first timeseries first average is wrong"); Assert.AreEqual(1.0, metrics[1].Timeseries[0].Data[1].Average, "Second metric first timeseries second average is wrong"); Assert.AreEqual(timestamp.AddMinutes(-1), metrics[1].Timeseries[0].Data[0].TimeStamp, "Second metric first timeseries first timestamp is wrong"); Assert.IsNull(metrics[1].Timeseries[0].Data[0].Total, "Second metric first timeseries first total should be null"); Assert.IsNull(metrics[1].Timeseries[0].Data[0].Maximum, "Second metric first timeseries first maximum should be null"); Assert.IsNull(metrics[1].Timeseries[0].Data[0].Minimum, "Second metric first timeseries first minimum should be null"); Assert.IsNull(metrics[1].Timeseries[0].Data[0].Count, "Second metric first timeseries first count should be null"); Assert.AreEqual(2.1, metrics[1].Timeseries[1].Data[0].Minimum, "Second metric second timeseries first minimum is wrong"); Assert.AreEqual(3.1, metrics[1].Timeseries[2].Data[0].Maximum, "Second metric third timeseries first maximum is wrong"); Assert.AreEqual(4.1, metrics[1].Timeseries[3].Data[0].Total, "Second metric forth timeseries first total is wrong"); Assert.AreEqual(1, metrics[1].Timeseries[4].Data[0].Count, "Second metric fifth timeseries first count is wrong"); Assert.AreEqual(1, metrics[1].Timeseries[0].MetaData.Count, "Second metric first timeseries metadata length is wrong"); Assert.AreEqual("Dimension1", metrics[1].Timeseries[0].MetaData[0].Key, "Second metric first timeseries first metadata key is wrong"); Assert.AreEqual("Dimension1Value1", metrics[1].Timeseries[0].MetaData[0].Value, "Second metric first timeseries first metadata value is wrong"); }
/// <summary> /// Calculate average time taken and a second metric for how many times it occurred /// </summary> /// <param name="category">Category of the metric</param> /// <param name="metricName">Name of the metric</param> /// <param name="timeTaken">How long the event being tracked took</param> public static void CountAndTime(string category, string metricName, TimeSpan timeTaken, bool autoReportZeroIfNothingReported = false) { MetricClient.QueueMetric(new Metric(category, metricName, MetricType.Counter) { Value = 1, Settings = new MetricSetting() { AutoReportZeroIfNothingReported = autoReportZeroIfNothingReported } }); MetricClient.QueueMetric(new Metric(category, metricName + " Time", MetricType.CounterTime) { Value = timeTaken.TotalSeconds }); }
public Task CreateContinuousTask(CancellationToken cancellationToken) { return(new Task(() => { var reader = new PerfmonCounterReader(); using (var messenger = new MetricClient(_metricPublishingConfig)) { foreach (var metricBatch in reader.StreamCounterSamples(_counterPaths, _counterSamplingConfig.SampleInterval, cancellationToken) .SelectMany(set => set.CounterSamples.ToMetrics(_counterSamplingConfig.AddInstanceNameToMetrics)) .Chunk(10)) { messenger.Send(metricBatch); } } }, cancellationToken)); }
public async Task WhenCallingGetResourceMetricDefinitionsHappyFlow() { string resourceUri = "/subscriptions/SUBSCRIPTION_ID/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/STORAGE_NAME"; var expectedDefinitions = GetMetricDefinitionsList(); var azureResponse = new AzureOperationResponse <IEnumerable <Microsoft.Azure.Management.Monitor.Fluent.Models.MetricDefinition> >() { Body = expectedDefinitions, Request = new HttpRequestMessage(), RequestId = "RequestId", Response = new HttpResponseMessage() }; this.metricDefinitionsOperationsMock.Setup(metric => metric.ListWithHttpMessagesAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Dictionary <string, List <string> > >(), It.IsAny <CancellationToken>())).ReturnsAsync(azureResponse); this.monitorManagementClientMock.SetupGet(monitorClient => monitorClient.MetricDefinitions).Returns(this.metricDefinitionsOperationsMock.Object); IMetricClient metricClient = new MetricClient(this.tracerMock.Object, this.monitorManagementClientMock.Object); List <MetricDefinition> definitions = (await metricClient.GetResourceMetricDefinitionsAsync(resourceUri, default(CancellationToken))).ToList(); // Validate that right Uri was used this.metricDefinitionsOperationsMock.Verify(metric => metric.ListWithHttpMessagesAsync(resourceUri, null, null, CancellationToken.None)); Assert.AreEqual(definitions.Count, 2, "2 definitions are expected"); }
public async Task WhenCallingGetResourceMetricDefinitionsHappyFlow() { string resourceUri = "/subscriptions/SUBSCRIPTION_ID/resourceGroups/RESOURCE_GROUP_NAME/providers/Microsoft.Storage/storageAccounts/STORAGE_NAME"; var expectedDefinitions = GetMetricDefinitionsList(); var azureResponse = new AzureOperationResponse <IEnumerable <Microsoft.Azure.Management.Monitor.Fluent.Models.MetricDefinition> >() { Body = expectedDefinitions, Request = new HttpRequestMessage(), RequestId = "RequestId", Response = new HttpResponseMessage() }; this.metricDefinitionsOperationsMock.Setup(metric => metric.ListWithHttpMessagesAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <Dictionary <string, List <string> > >(), It.IsAny <CancellationToken>())).ReturnsAsync(azureResponse); this.monitorManagementClientMock.SetupGet(monitorClient => monitorClient.MetricDefinitions).Returns(this.metricDefinitionsOperationsMock.Object); IMetricClient metricClient = new MetricClient(this.tracerMock.Object, this.resourceIdentifier.SubscriptionId, this.monitorManagementClientMock.Object); List <MetricDefinition> definitions = (await metricClient.GetResourceMetricDefinitionsAsync(resourceUri, default(CancellationToken))).ToList(); // Validate that right Uri was used this.metricDefinitionsOperationsMock.Verify(metric => metric.ListWithHttpMessagesAsync(resourceUri, null, null, CancellationToken.None)); Assert.AreEqual(definitions.Count, 2, "2 definitions are expected"); // Validate first metric was converted successfully Assert.AreEqual(expectedDefinitions.Count, definitions.Count, "Definition count isn't correct"); for (int i = 0; i < expectedDefinitions.Count; i++) { Assert.AreEqual(expectedDefinitions[i].Name.Value, definitions[i].Name, "Metric name isn't correct"); Assert.IsTrue(expectedDefinitions[i].MetricAvailabilities.Select(x => Tuple.Create(x.Retention, x.TimeGrain)).SequenceEqual(definitions[i].Availabilities), "Metric availabilities aren't correct"); Assert.IsTrue(expectedDefinitions[i].Dimensions.Select(x => x.Value).SequenceEqual(definitions[i].Dimensions), "Metric dimensions aren't correct"); Assert.AreEqual(expectedDefinitions[i].IsDimensionRequired, definitions[i].IsDimensionRequired, "Metric is dimension required isn't correct"); Assert.AreEqual(expectedDefinitions[i].PrimaryAggregationType?.ToString(), definitions[i].PrimaryAggregationType?.ToString(), "Metric primary aggregation type isn't correct"); Assert.AreEqual(expectedDefinitions[i].Unit?.ToString(), definitions[i].Unit, "Metric unit isn't correct"); } }
public static LatestAggregate GetLatest(string category, string metricName) { return(MetricClient.GetLatestMetric(category, metricName)); }
public static List <LatestAggregate> GetLatestAllMetrics() { return(MetricClient.GetLatestMetrics()); }
public async Task WhenMetricIsNull_CreateThrowsException() { var client = new MetricClient(null); await Assert.ThrowsAsync <ArgumentNullException>(() => client.Create(null)); }