Example #1
0
        public async Task MinimumAzureFunctionsDatabricksProject_WithEmbeddedTimer_ReportsAsMetricPeriodically()
        {
            ApplicationInsightsConfig applicationInsightsConfig = _config.GetApplicationInsightsConfig();
            var parameters = RunParameters.CreateNotebookParams(Enumerable.Empty <KeyValuePair <string, string> >());

            using (var project = AzureFunctionsDatabricksProject.StartNew(_config, _outputWriter))
            {
                using (var client = DatabricksClient.CreateClient(project.DatabricksConfig.BaseUrl, project.DatabricksConfig.SecurityToken))
                {
                    // Act
                    await client.Jobs.RunNow(project.DatabricksConfig.JobId, parameters);
                    await WaitUntilDatabricksJobRunIsCompleted(client, project.DatabricksConfig.JobId);
                }
            }

            // Assert
            using (ApplicationInsightsDataClient client = CreateApplicationInsightsClient(applicationInsightsConfig.ApiKey))
            {
                await RetryAssertUntilTelemetryShouldBeAvailableAsync(async() =>
                {
                    const string past10MinFilter = "PT0.1H";
                    var bodySchema = new MetricsPostBodySchema(
                        id: Guid.NewGuid().ToString(),
                        parameters: new MetricsPostBodySchemaParameters($"customMetrics/{applicationInsightsConfig.MetricName}", timespan: past10MinFilter));

                    IList <MetricsResultsItem> results =
                        await client.Metrics.GetMultipleAsync(applicationInsightsConfig.ApplicationId, new List <MetricsPostBodySchema> {
                        bodySchema
                    });

                    Assert.NotEmpty(results);
                    Assert.All(results, result => Assert.NotNull(result.Body.Value));
                }, timeout : TimeSpan.FromMinutes(2));
            }
        }
        public async Task FinishedDatabricksJobRun_GetsNoticedByRepeatedlyDatabricksJob_ReportsAsMetric()
        {
            // Arrange
            string baseUrl = GetDatabricksUrl();
            string token = GetDatabricksToken();
            int jobId = GetDatabricksJobId();

            using (var client = DatabricksClient.CreateClient(baseUrl, token))
            {
                // Act
                await client.Jobs.RunNow(jobId, RunParameters.CreateNotebookParams(Enumerable.Empty<KeyValuePair<string, string>>()));

                // Assert
                RetryAssertion(
                    () => Assert.Contains(_spyLogger.Messages, msg => msg.StartsWith("Metric Databricks Job Completed")),
                    timeout: TimeSpan.FromMinutes(3),
                    interval: TimeSpan.FromSeconds(1));
            }
        }
Example #3
0
        public async Task MinimumAzureFunctionsDatabricksProject_WithEmbeddedTimer_ReportsAsMetricPeriodically()
        {
            var parameters = RunParameters.CreateNotebookParams(Enumerable.Empty <KeyValuePair <string, string> >());

            using (var project = AzureFunctionsDatabricksProject.StartNew(_config, Logger))
                using (var client = DatabricksClient.CreateClient(project.AzureFunctionDatabricksConfig.BaseUrl, project.AzureFunctionDatabricksConfig.SecurityToken))
                {
                    JobSettings settings = CreateEmptyJobSettings();
                    long        jobId    = await client.Jobs.Create(settings);

                    try
                    {
                        // Act
                        await client.Jobs.RunNow(jobId, parameters);
                        await WaitUntilDatabricksJobRunIsCompleted(client, jobId);
                    }
                    finally
                    {
                        await client.Jobs.Delete(jobId);
                    }
                }

            // Assert
            await RetryAssertUntilTelemetryShouldBeAvailableAsync(async client =>
            {
                MetricsPostBodySchema bodySchema   = CreateMetricPostBodySchemaForDatabricksTracking();
                IList <MetricsResultsItem> results =
                    await client.Metrics.GetMultipleAsync(ApplicationInsightsConfig.ApplicationId, new List <MetricsPostBodySchema> {
                    bodySchema
                });

                Assert.NotEmpty(results);
                Assert.All(results, result => Assert.NotNull(result.Body.Value));
            },
                                                                  timeout : TimeSpan.FromMinutes(2));
        }