private static AzureMonitorClient CreateNewAzureMonitorClient(AzureEnvironment cloud, string tenantId, string subscriptionId, MetricSinkWriter metricSinkWriter, IAzureScrapingPrometheusMetricsCollector azureScrapingPrometheusMetricsCollector, IMemoryCache resourceMetricDefinitionMemoryCache, IConfiguration configuration, IOptions <AzureMonitorIntegrationConfiguration> azureMonitorIntegrationConfiguration, IOptions <AzureMonitorLoggingConfiguration> azureMonitorLoggingConfiguration, ILoggerFactory loggerFactory)
{
var azureCredentials = AzureAuthenticationFactory.GetConfiguredAzureAuthentication(configuration);
var azureMonitorClient = new AzureMonitorClient(cloud, tenantId, subscriptionId, azureCredentials, metricSinkWriter, azureScrapingPrometheusMetricsCollector, resourceMetricDefinitionMemoryCache, loggerFactory, azureMonitorIntegrationConfiguration, azureMonitorLoggingConfiguration);
return(azureMonitorClient);
}
private static AzureMonitorClient CreateNewAzureMonitorClient(AzureEnvironment cloud, string tenantId, string subscriptionId, MetricSinkWriter metricSinkWriter, IRuntimeMetricsCollector metricsCollector, IConfiguration configuration, IOptions <AzureMonitorLoggingConfiguration> azureMonitorLoggingConfiguration, ILoggerFactory loggerFactory)
{
var azureCredentials = DetermineAzureCredentials(configuration);
var azureMonitorClient = new AzureMonitorClient(cloud, tenantId, subscriptionId, azureCredentials.ApplicationId, azureCredentials.Secret, azureMonitorLoggingConfiguration, metricSinkWriter, metricsCollector, loggerFactory);
return(azureMonitorClient);
}
public async Task ScrapeAsync(MetricDefinition metricDefinition)
{
try
{
if (metricDefinition == null)
{
throw new ArgumentNullException(nameof(metricDefinition));
}
if (!(metricDefinition is TMetricDefinition castedMetricDefinition))
{
throw new ArgumentException($"Could not cast metric definition of type '{metricDefinition.ResourceType}' to {typeof(TMetricDefinition)}. Payload: {JsonConvert.SerializeObject(metricDefinition)}");
}
var azureMonitorClient = new AzureMonitorClient(AzureMetadata.TenantId, AzureMetadata.SubscriptionId, AzureCredentials.ApplicationId, AzureCredentials.Secret);
var foundMetricValue = await ScrapeResourceAsync(azureMonitorClient, castedMetricDefinition);
var gauge = Metrics.CreateGauge(metricDefinition.Name, metricDefinition.Description);
gauge.Set(foundMetricValue);
}
catch (Exception exception)
{
_exceptionTracker.Track(exception);
}
}
private AzureMonitorClient CreateAzureMonitorClient(AzureMetadata azureMetadata, IRuntimeMetricsCollector runtimeMetricsCollector)
{
var azureCredentials = DetermineAzureCredentials();
var azureMonitorClient = new AzureMonitorClient(azureMetadata.TenantId, azureMetadata.SubscriptionId, azureCredentials.ApplicationId, azureCredentials.Secret, runtimeMetricsCollector, _logger);
return(azureMonitorClient);
}
public MetricScrapingJob(string jobName,
ScrapeDefinition <IAzureResourceDefinition> metricScrapeDefinition,
MetricSinkWriter metricSinkWriter,
IPrometheusMetricWriter prometheusMetricWriter,
MetricScraperFactory metricScraperFactory,
AzureMonitorClient azureMonitorClient,
ILogger <MetricScrapingJob> logger)
{
Guard.NotNull(metricScrapeDefinition, nameof(metricScrapeDefinition));
Guard.NotNull(prometheusMetricWriter, nameof(prometheusMetricWriter));
Guard.NotNull(metricScraperFactory, nameof(metricScraperFactory));
Guard.NotNull(azureMonitorClient, nameof(azureMonitorClient));
Guard.NotNullOrWhitespace(jobName, nameof(jobName));
Guard.NotNull(logger, nameof(logger));
Name = jobName;
_metricScrapeDefinition = metricScrapeDefinition;
_prometheusMetricWriter = prometheusMetricWriter;
_metricSinkWriter = metricSinkWriter;
_logger = logger;
_metricScraperFactory = metricScraperFactory;
_azureMonitorClient = azureMonitorClient;
}
/// <inheritdoc />
protected override async Task <ScrapeResult> ScrapeResourceAsync(string subscriptionId, ScrapeDefinition <IAzureResourceDefinition> scrapeDefinition, TResourceDefinition resourceDefinition, AggregationType aggregationType, TimeSpan aggregationInterval)
{
Guard.NotNull(scrapeDefinition, nameof(scrapeDefinition));
Guard.NotNull(scrapeDefinition.AzureMetricConfiguration, nameof(scrapeDefinition.AzureMetricConfiguration));
var metricName = scrapeDefinition.AzureMetricConfiguration.MetricName;
// Compose URI of the resource to measure
var resourceUri = BuildResourceUri(subscriptionId, scrapeDefinition, resourceDefinition);
// Determine the metric filter to use, if any
var metricFilter = DetermineMetricFilter(resourceDefinition);
// Determine the metric dimension to use, if any
var dimensionName = DetermineMetricDimension(resourceDefinition, scrapeDefinition.AzureMetricConfiguration?.Dimension);
// Query Azure Monitor for metrics
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, dimensionName, aggregationType, aggregationInterval, resourceUri, metricFilter);
// Provide more metric labels, if we need to
var metricLabels = DetermineMetricLabels(resourceDefinition);
// Enrich measured metrics, in case we need to
var finalMetricValues = EnrichMeasuredMetrics(resourceDefinition, dimensionName, foundMetricValue);
// We're done!
return(new ScrapeResult(subscriptionId, scrapeDefinition.ResourceGroupName, resourceDefinition.ResourceName, resourceUri, finalMetricValues, metricLabels));
}
protected override async Task <ScrapeResult> ScrapeResourceAsync(string subscriptionId, ScrapeDefinition <AzureResourceDefinition> scrapeDefinition, GenericAzureResourceDefinition resource, AggregationType aggregationType, TimeSpan aggregationInterval)
{
var resourceUri = string.Format(ResourceUriTemplate, subscriptionId, scrapeDefinition.ResourceGroupName, resource.ResourceUri);
var metricName = scrapeDefinition.AzureMetricConfiguration.MetricName;
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, aggregationType, aggregationInterval, resourceUri, resource.Filter);
return(new ScrapeResult(subscriptionId, scrapeDefinition.ResourceGroupName, resourceUri, foundMetricValue));
}
private static AzureMonitorClient ConfigureAzureMonitorClient(MetricsDeclaration metricsDeclaration, IRuntimeMetricsCollector runtimeMetricCollector, IConfiguration configuration, IOptions <AzureMonitorLoggingConfiguration> azureMonitorLoggingConfiguration, ILoggerFactory loggerFactory)
{
var azureCredentials = DetermineAzureCredentials(configuration);
var azureMetadata = metricsDeclaration.AzureMetadata;
var azureMonitorClient = new AzureMonitorClient(azureMetadata.Cloud, azureMetadata.TenantId, azureMetadata.SubscriptionId, azureCredentials.ApplicationId, azureCredentials.Secret, azureMonitorLoggingConfiguration, runtimeMetricCollector, loggerFactory);
return(azureMonitorClient);
}
protected override async Task <double> ScrapeResourceAsync(GenericAzureMetricDefinition metricDefinition, AggregationType aggregationType, TimeSpan aggregationInterval)
{
var resourceUri = string.Format(ResourceUriTemplate, AzureMetadata.SubscriptionId, AzureMetadata.ResourceGroupName, metricDefinition.ResourceUri);
var metricName = metricDefinition.AzureMetricConfiguration.MetricName;
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, aggregationType, aggregationInterval, resourceUri, metricDefinition.Filter);
return(foundMetricValue);
}
protected override async Task <ScrapeResult> ScrapeResourceAsync(string subscriptionId, string resourceGroupName, VirtualMachineMetricDefinition metricDefinition, AggregationType aggregationType, TimeSpan aggregationInterval)
{
var resourceUri = string.Format(ResourceUriTemplate, AzureMetadata.SubscriptionId, AzureMetadata.ResourceGroupName, metricDefinition.VirtualMachineName);
var metricName = metricDefinition.AzureMetricConfiguration.MetricName;
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, aggregationType, aggregationInterval, resourceUri);
return(new ScrapeResult(resourceUri, foundMetricValue));
}
protected override async Task <double> ScrapeResourceAsync(string subscriptionId, string resourceGroupName, ServiceBusQueueMetricDefinition metricDefinition, AggregationType aggregationType, TimeSpan aggregationInterval)
{
var resourceUri = string.Format(ResourceUriTemplate, subscriptionId, resourceGroupName, metricDefinition.Namespace);
var filter = $"EntityName eq '{metricDefinition.QueueName}'";
var metricName = metricDefinition.AzureMetricConfiguration.MetricName;
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, aggregationType, aggregationInterval, resourceUri, filter);
return(foundMetricValue);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="azureMonitorClient">Client to communicate with Azure Monitor</param>
/// <param name="metricSinkWriter">Writer to send metrics to all configured sinks</param>
/// <param name="logger">General logger</param>
public ScraperConfiguration(AzureMonitorClient azureMonitorClient, MetricSinkWriter metricSinkWriter, ILogger logger)
{
Guard.NotNull(azureMonitorClient, nameof(azureMonitorClient));
Guard.NotNull(logger, nameof(logger));
Guard.NotNull(metricSinkWriter, nameof(metricSinkWriter));
AzureMonitorClient = azureMonitorClient;
Logger = logger;
MetricSinkWriter = metricSinkWriter;
}
protected override async Task <double> ScrapeResourceAsync(AzureMonitorClient azureMonitorClient, ServiceBusQueueMetricDefinition metricDefinition)
{
var resourceUri = string.Format(ResourceUriTemplate, AzureMetadata.SubscriptionId, AzureMetadata.ResourceGroupName, metricDefinition.Namespace);
var filter = $"EntityName eq '{metricDefinition.QueueName}'";
var metricName = metricDefinition.AzureMetricConfiguration.MetricName;
var foundMetricValue = await azureMonitorClient.QueryMetricAsync(metricName, metricDefinition.AzureMetricConfiguration.Aggregation, resourceUri, filter);
return(foundMetricValue);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="azureMonitorClient">Client to communicate with Azure Monitor</param>
/// <param name="metricSinkWriter">Writer to send metrics to all configured sinks</param>
/// <param name="azureScrapingPrometheusMetricsCollector">Collector to send metrics related to the runtime</param>
/// <param name="logger">General logger</param>
public ScraperConfiguration(AzureMonitorClient azureMonitorClient, MetricSinkWriter metricSinkWriter, IAzureScrapingPrometheusMetricsCollector azureScrapingPrometheusMetricsCollector, ILogger logger)
{
Guard.NotNull(azureMonitorClient, nameof(azureMonitorClient));
Guard.NotNull(logger, nameof(logger));
Guard.NotNull(metricSinkWriter, nameof(metricSinkWriter));
Guard.NotNull(azureScrapingPrometheusMetricsCollector, nameof(azureScrapingPrometheusMetricsCollector));
AzureMonitorClient = azureMonitorClient;
Logger = logger;
MetricSinkWriter = metricSinkWriter;
AzureScrapingPrometheusMetricsCollector = azureScrapingPrometheusMetricsCollector;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="azureMetadata">Metadata concerning the Azure resources</param>
/// <param name="azureMonitorClient">Client to communicate with Azure Monitor</param>
/// <param name="prometheusMetricWriter">Metrics collector for our Prometheus scraping endpoint</param>
/// <param name="logger">General logger</param>
public ScraperConfiguration(AzureMetadata azureMetadata, AzureMonitorClient azureMonitorClient, IPrometheusMetricWriter prometheusMetricWriter, ILogger logger)
{
Guard.NotNull(azureMetadata, nameof(azureMetadata));
Guard.NotNull(azureMonitorClient, nameof(azureMonitorClient));
Guard.NotNull(prometheusMetricWriter, nameof(prometheusMetricWriter));
Guard.NotNull(logger, nameof(logger));
AzureMetadata = azureMetadata;
AzureMonitorClient = azureMonitorClient;
PrometheusMetricWriter = prometheusMetricWriter;
Logger = logger;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="azureMetadata">Metadata concerning the Azure resources</param>
/// <param name="azureMonitorClient">Client to communicate with Azure Monitor</param>
/// <param name="logger">General logger</param>
/// <param name="exceptionTracker">Exception tracker</param>
protected Scraper(AzureMetadata azureMetadata, AzureMonitorClient azureMonitorClient, ILogger logger,
IExceptionTracker exceptionTracker)
{
Guard.NotNull(exceptionTracker, nameof(exceptionTracker));
Guard.NotNull(azureMetadata, nameof(azureMetadata));
Guard.NotNull(azureMonitorClient, nameof(azureMonitorClient));
_logger = logger;
_exceptionTracker = exceptionTracker;
AzureMetadata = azureMetadata;
AzureMonitorClient = azureMonitorClient;
}
/// <inheritdoc />
protected override async Task <ScrapeResult> ScrapeResourceAsync(string subscriptionId, ScrapeDefinition <IAzureResourceDefinition> scrapeDefinition, TResourceDefinition resourceDefinition, AggregationType aggregationType, TimeSpan aggregationInterval)
{
var resourceUri = BuildResourceUri(subscriptionId, scrapeDefinition, resourceDefinition);
var metricFilter = DetermineMetricFilter(resourceDefinition);
var metricName = scrapeDefinition.AzureMetricConfiguration.MetricName;
var dimensionName = scrapeDefinition.AzureMetricConfiguration.Dimension?.Name;
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, dimensionName, aggregationType, aggregationInterval, resourceUri, metricFilter);
var metricLabels = DetermineMetricLabels(resourceDefinition);
return(new ScrapeResult(subscriptionId, scrapeDefinition.ResourceGroupName, resourceDefinition.ResourceName, resourceUri, foundMetricValue, metricLabels));
}
protected override async Task <ScrapeResult> ScrapeResourceAsync(string subscriptionId, ScrapeDefinition <AzureResourceDefinition> scrapeDefinition, ServiceBusQueueResourceDefinition resource, AggregationType aggregationType, TimeSpan aggregationInterval)
{
var resourceUri = string.Format(ResourceUriTemplate, subscriptionId, scrapeDefinition.ResourceGroupName, resource.Namespace);
var filter = $"EntityName eq '{resource.QueueName}'";
var metricName = scrapeDefinition.AzureMetricConfiguration.MetricName;
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, aggregationType, aggregationInterval, resourceUri, filter);
var labels = new Dictionary <string, string>
{
{ "entity_name", resource.QueueName }
};
return(new ScrapeResult(subscriptionId, scrapeDefinition.ResourceGroupName, resource.Namespace, resourceUri, foundMetricValue, labels));
}
/// <inheritdoc />
protected override async Task <ScrapeResult> ScrapeResourceAsync(string subscriptionId, ScrapeDefinition <IAzureResourceDefinition> scrapeDefinition, TResourceDefinition resourceDefinition, AggregationType aggregationType, TimeSpan aggregationInterval)
{
Guard.NotNull(scrapeDefinition, nameof(scrapeDefinition));
Guard.NotNull(scrapeDefinition.AzureMetricConfiguration, nameof(scrapeDefinition.AzureMetricConfiguration));
var metricName = scrapeDefinition.AzureMetricConfiguration.MetricName;
// Compose URI of the resource to measure
var resourceUri = BuildResourceUri(subscriptionId, scrapeDefinition, resourceDefinition);
// Determine the metric filter to use, if any
var metricFilter = DetermineMetricFilter(metricName, resourceDefinition);
// Determine the metric limit to use, if any
var metricLimit = DetermineMetricLimit(scrapeDefinition);
// Determine the metric dimension to use, if any
var dimensionName = DetermineMetricDimension(metricName, resourceDefinition, scrapeDefinition.AzureMetricConfiguration?.Dimension);
List <MeasuredMetric> measuredMetrics = new List <MeasuredMetric>();
try
{
// Query Azure Monitor for metrics
measuredMetrics = await AzureMonitorClient.QueryMetricAsync(metricName, dimensionName, aggregationType, aggregationInterval, resourceUri, metricFilter, metricLimit);
}
catch (MetricInformationNotFoundException metricsNotFoundException)
{
Logger.LogWarning("No metric information found for metric {MetricName} with dimension {MetricDimension}. Details: {Details}", metricsNotFoundException.Name, metricsNotFoundException.Dimension, metricsNotFoundException.Details);
var measuredMetric = string.IsNullOrWhiteSpace(dimensionName) ? MeasuredMetric.CreateWithoutDimension(null) : MeasuredMetric.CreateForDimension(null, dimensionName, "unknown");
measuredMetrics.Add(measuredMetric);
}
// Provide more metric labels, if we need to
var metricLabels = DetermineMetricLabels(resourceDefinition);
// Enrich measured metrics, in case we need to
var finalMetricValues = EnrichMeasuredMetrics(resourceDefinition, dimensionName, measuredMetrics);
// We're done!
return(new ScrapeResult(subscriptionId, scrapeDefinition.ResourceGroupName, resourceDefinition.ResourceName, resourceUri, finalMetricValues, metricLabels));
}
public ResourceScrapingJob(string jobName,
ScrapeDefinition <IAzureResourceDefinition> metricScrapeDefinition,
MetricSinkWriter metricSinkWriter,
MetricScraperFactory metricScraperFactory,
AzureMonitorClient azureMonitorClient,
ILogger <ResourceScrapingJob> logger)
: base(jobName, logger)
{
Guard.NotNull(metricScrapeDefinition, nameof(metricScrapeDefinition));
Guard.NotNull(metricScraperFactory, nameof(metricScraperFactory));
Guard.NotNull(azureMonitorClient, nameof(azureMonitorClient));
Guard.NotNull(metricSinkWriter, nameof(metricSinkWriter));
_metricScrapeDefinition = metricScrapeDefinition;
_metricSinkWriter = metricSinkWriter;
_metricScraperFactory = metricScraperFactory;
_azureMonitorClient = azureMonitorClient;
}
protected override async Task <ScrapeResult> ScrapeResourceAsync(string subscriptionId, ScrapeDefinition <AzureResourceDefinition> scrapeDefinition, AzureSqlDatabaseResourceDefinition resource, AggregationType aggregationType, TimeSpan aggregationInterval)
{
var resourceUri = string.Format(
ResourceUriTemplate,
AzureMetadata.SubscriptionId,
scrapeDefinition.ResourceGroupName,
resource.ServerName,
resource.DatabaseName);
var metricName = scrapeDefinition.AzureMetricConfiguration.MetricName;
var foundMetricValue = await AzureMonitorClient.QueryMetricAsync(metricName, aggregationType, aggregationInterval, resourceUri);
var labels = new Dictionary <string, string>
{
{ "server", resource.ServerName },
{ "database", resource.DatabaseName }
};
return(new ScrapeResult(subscriptionId, scrapeDefinition.ResourceGroupName, null, resourceUri, foundMetricValue, labels));
}
public MetricScrapingJob(ScrapeDefinition <IAzureResourceDefinition> metric,
IMetricsDeclarationProvider metricsDeclarationProvider,
IPrometheusMetricWriter prometheusMetricWriter,
MetricScraperFactory metricScraperFactory,
AzureMonitorClient azureMonitorClient,
ILogger <MetricScrapingJob> logger)
{
Guard.NotNull(metric, nameof(metric));
Guard.NotNull(metricsDeclarationProvider, nameof(metricsDeclarationProvider));
Guard.NotNull(prometheusMetricWriter, nameof(prometheusMetricWriter));
Guard.NotNull(metricScraperFactory, nameof(metricScraperFactory));
Guard.NotNull(azureMonitorClient, nameof(azureMonitorClient));
Guard.NotNull(logger, nameof(logger));
_metric = metric;
_metricsDeclarationProvider = metricsDeclarationProvider;
_prometheusMetricWriter = prometheusMetricWriter;
_logger = logger;
_metricScraperFactory = metricScraperFactory;
_azureMonitorClient = azureMonitorClient;
ConfigureJob();
}
private static AzureMonitorClient CreateAzureMonitorClient(AzureMetadata azureMetadata, AzureCredentials azureCredentials, IRuntimeMetricsCollector runtimeMetricsCollector, ILogger logger)
{
var azureMonitorClient = new AzureMonitorClient(azureMetadata.TenantId, azureMetadata.SubscriptionId, azureCredentials.ApplicationId, azureCredentials.Secret, runtimeMetricsCollector, logger);
return(azureMonitorClient);
}
public GenericScraper(AzureMetadata azureMetadata, MetricDefaults metricDefaults, AzureMonitorClient azureMonitorClient, ILogger logger, IExceptionTracker exceptionTracker)
: base(azureMetadata, metricDefaults, azureMonitorClient, logger, exceptionTracker)
{
}
public StorageQueueScraper(AzureMetadata azureMetadata, AzureMonitorClient azureMonitorClient, ILogger logger, IExceptionTracker exceptionTracker)
: base(azureMetadata, azureMonitorClient, logger, exceptionTracker)
{
_azureStorageQueueClient = new AzureStorageQueueClient(logger);
}
public ContainerRegistryScraper(AzureMetadata azureMetadata, AzureMonitorClient azureMonitorClient, ILogger logger, IExceptionTracker exceptionTracker)
: base(azureMetadata, azureMonitorClient, logger, exceptionTracker)
{
}
public CosmosDbScraper(AzureMetadata azureMetadata, AzureMonitorClient azureMonitorClient, ILogger logger, IExceptionTracker exceptionTracker)
: base(azureMetadata, azureMonitorClient, logger, exceptionTracker)
{
}
private async Task ScrapeResourceAsync(IAzureResourceDefinition discoveredResource, AzureMonitorClient azureMonitorClient)
{
try
{
var scrapingDefinition = _metricDefinition.CreateScrapeDefinition(discoveredResource, _azureMetadata);
var scraper = _metricScraperFactory.CreateScraper(scrapingDefinition.Resource.ResourceType, _metricSinkWriter, azureMonitorClient);
await scraper.ScrapeAsync(scrapingDefinition);
}
catch (Exception exception)
{
Logger.LogCritical(exception, "Failed to scrape resource collection {Resource}: {Exception}", discoveredResource.UniqueName, exception.Message);
}
}
public VirtualMachineScraper(AzureMetadata azureMetadata, AzureMonitorClient azureMonitorClient, ILogger logger, IExceptionTracker exceptionTracker)
: base(azureMetadata, azureMonitorClient, logger, exceptionTracker)
{
}
/// <summary>
/// Creates a scraper that is capable of scraping a specific resource type
/// </summary>
/// <param name="metricDefinitionResourceType">Resource type to scrape</param>
/// <param name="metricSinkWriter">Writer to send metrics to all sinks</param>
/// <param name="azureMonitorClient">Client to interact with Azure Monitor</param>
public IScraper <IAzureResourceDefinition> CreateScraper(ResourceType metricDefinitionResourceType, MetricSinkWriter metricSinkWriter, AzureMonitorClient azureMonitorClient)
{
var scraperConfiguration = new ScraperConfiguration(azureMonitorClient, metricSinkWriter, _logger);
switch (metricDefinitionResourceType)
{
case ResourceType.ApiManagement:
return(new ApiManagementScraper(scraperConfiguration));
case ResourceType.ApplicationGateway:
return(new ApplicationGatewayScraper(scraperConfiguration));
case ResourceType.AppPlan:
return(new AppPlanScraper(scraperConfiguration));
case ResourceType.BlobStorage:
return(new BlobStorageScraper(scraperConfiguration));
case ResourceType.ContainerInstance:
return(new ContainerInstanceScraper(scraperConfiguration));
case ResourceType.ContainerRegistry:
return(new ContainerRegistryScraper(scraperConfiguration));
case ResourceType.CosmosDb:
return(new CosmosDbScraper(scraperConfiguration));
case ResourceType.DeviceProvisioningService:
return(new DeviceProvisioningServiceScraper(scraperConfiguration));
case ResourceType.EventHubs:
return(new EventHubsScraper(scraperConfiguration));
case ResourceType.ExpressRouteCircuit:
return(new ExpressRouteCircuitScraper(scraperConfiguration));
case ResourceType.FileStorage:
return(new FileStorageScraper(scraperConfiguration));
case ResourceType.FunctionApp:
return(new FunctionAppScraper(scraperConfiguration));
case ResourceType.Generic:
return(new GenericScraper(scraperConfiguration));
case ResourceType.IoTHub:
return(new IoTHubScraper(scraperConfiguration));
case ResourceType.KeyVault:
return(new KeyVaultScraper(scraperConfiguration));
case ResourceType.NetworkGateway:
return(new NetworkGatewayScraper(scraperConfiguration));
case ResourceType.NetworkInterface:
return(new NetworkInterfaceScraper(scraperConfiguration));
case ResourceType.LogicApp:
return(new LogicAppScraper(scraperConfiguration));
case ResourceType.PostgreSql:
return(new PostgreSqlScraper(scraperConfiguration));
case ResourceType.RedisCache:
return(new RedisCacheScraper(scraperConfiguration));
case ResourceType.ServiceBusQueue:
return(new ServiceBusQueueScraper(scraperConfiguration));
case ResourceType.SqlDatabase:
return(new SqlDatabaseScraper(scraperConfiguration));
case ResourceType.SqlManagedInstance:
return(new SqlManagedInstanceScraper(scraperConfiguration));
case ResourceType.SqlServer:
return(new SqlServerScraper(scraperConfiguration));
case ResourceType.StorageAccount:
return(new StorageAccountScraper(scraperConfiguration));
case ResourceType.StorageQueue:
return(new StorageQueueScraper(scraperConfiguration));
case ResourceType.VirtualMachine:
return(new VirtualMachineScraper(scraperConfiguration));
case ResourceType.VirtualMachineScaleSet:
return(new VirtualMachineScaleSetScraper(scraperConfiguration));
case ResourceType.WebApp:
return(new WebAppScraper(scraperConfiguration));
default:
throw new ArgumentOutOfRangeException();
}
}
