void Initialize()
{
var light = GameObject.Find("Directional Light");
if (light == null)
{
return;
}
m_LightingInfoDefinition = DatasetCapture.RegisterMetricDefinition("lighting info", "Per-frame light color and orientation", id: k_LightingInfoGuid);
m_Light = light.GetComponent <Light>();
// To simulate phong shading we turn off shadows
m_Light.shadows = LightShadows.None;
m_IsInitialized = true;
// Try to find game object here because scene may not be initialized on Create()
if (m_InitParams == null)
{
m_InitParams = GameObject.Find("Management")?.GetComponentInChildren <ProjectInitialization>();
if (m_InitParams == null)
{
Debug.LogWarning("Unable to find Management object. Will not randomize lighting.");
return;
}
}
}
private static void AssertRedisCacheMetricDefinition(MetricDefinition deserializedRedisCacheMetricDefinition, RedisCacheMetricDefinitionV1 redisCacheMetricDefinition)
{
var deserializedResource = deserializedRedisCacheMetricDefinition.Resources.Single() as RedisCacheResourceDefinition;
Assert.NotNull(deserializedResource);
Assert.Equal(redisCacheMetricDefinition.CacheName, deserializedResource.CacheName);
}
private async Task ScrapeMetric(AzureMetadata azureMetadata, MetricDefinition metricDefinitionDefinition)
{
_logger.LogInformation("Scraping '{metricName}' for resource type '{resourceType}'", metricDefinitionDefinition.Name, metricDefinitionDefinition.ResourceType);
var scraper = MetricScraperFactory.CreateScraper(azureMetadata, metricDefinitionDefinition.ResourceType, _logger, _exceptionTracker);
await scraper.ScrapeAsync(metricDefinitionDefinition);
}
private static void AssertNetworkInterfaceMetricDefinition(MetricDefinition deserializedNetworkInterfaceMetricDefinition, NetworkInterfaceMetricDefinitionV1 networkInterfaceMetricDefinition)
{
var deserializedResource = deserializedNetworkInterfaceMetricDefinition.Resources.Single() as NetworkInterfaceResourceDefinition;
Assert.NotNull(deserializedResource);
Assert.Equal(networkInterfaceMetricDefinition.NetworkInterfaceName, deserializedResource.NetworkInterfaceName);
}
private static void AssertContainerRegistryMetricDefinition(MetricDefinition deserializedContainerRegistryMetricDefinition, ContainerRegistryMetricDefinitionV1 containerRegistryMetricDefinition)
{
var deserializedResource = deserializedContainerRegistryMetricDefinition.Resources.Single() as ContainerRegistryResourceDefinition;
Assert.NotNull(deserializedResource);
Assert.Equal(containerRegistryMetricDefinition.RegistryName, deserializedResource.RegistryName);
}
public ResourceDiscoveryGroupScrapingJob(string jobName, string resourceDiscoveryGroupName, AzureMetadata azureMetadata, MetricDefinition metricDefinition, ResourceDiscoveryRepository resourceDiscoveryRepository,
MetricSinkWriter metricSinkWriter,
MetricScraperFactory metricScraperFactory,
AzureMonitorClientFactory azureMonitorClientFactory, IRuntimeMetricsCollector runtimeMetricCollector, IConfiguration configuration, IOptions <AzureMonitorLoggingConfiguration> azureMonitorLoggingConfiguration, ILoggerFactory loggerFactory,
ILogger <ResourceDiscoveryGroupScrapingJob> logger)
: base(jobName, logger)
{
Guard.NotNullOrWhitespace(resourceDiscoveryGroupName, nameof(resourceDiscoveryGroupName));
Guard.NotNull(resourceDiscoveryRepository, nameof(resourceDiscoveryRepository));
Guard.NotNull(metricDefinition, nameof(metricDefinition));
Guard.NotNull(azureMetadata, nameof(azureMetadata));
Guard.NotNullOrWhitespace(jobName, nameof(jobName));
Guard.NotNull(metricScraperFactory, nameof(metricScraperFactory));
Guard.NotNull(azureMonitorClientFactory, nameof(azureMonitorClientFactory));
Guard.NotNull(runtimeMetricCollector, nameof(runtimeMetricCollector));
Guard.NotNull(configuration, nameof(configuration));
Guard.NotNull(azureMonitorLoggingConfiguration, nameof(azureMonitorLoggingConfiguration));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(metricSinkWriter, nameof(metricSinkWriter));
ResourceDiscoveryGroupName = resourceDiscoveryGroupName;
_azureMetadata = azureMetadata;
_metricDefinition = metricDefinition;
_resourceDiscoveryRepository = resourceDiscoveryRepository;
_metricSinkWriter = metricSinkWriter;
_runtimeMetricCollector = runtimeMetricCollector;
_azureMonitorClientFactory = azureMonitorClientFactory;
_configuration = configuration;
_azureMonitorLoggingConfiguration = azureMonitorLoggingConfiguration;
_loggerFactory = loggerFactory;
_metricScraperFactory = metricScraperFactory;
}
public IEnumerable <string> Validate(MetricDefinition metricDefinition)
{
Guard.NotNull(metricDefinition, nameof(metricDefinition));
var errorMessages = new List <string>();
var configuredDimension = metricDefinition.AzureMetricConfiguration?.Dimension?.Name;
if (string.IsNullOrWhiteSpace(configuredDimension) == false &&
configuredDimension.Equals(UnsupportedEntityDimension, StringComparison.InvariantCultureIgnoreCase))
{
errorMessages.Add($"Dimension '{UnsupportedEntityDimension}' is not supported for now");
}
foreach (var resourceDefinition in metricDefinition.Resources.Cast <ServiceBusQueueResourceDefinition>())
{
if (string.IsNullOrWhiteSpace(resourceDefinition.Namespace))
{
errorMessages.Add("No Service Bus Namespace is configured");
}
if (string.IsNullOrWhiteSpace(resourceDefinition.QueueName))
{
errorMessages.Add("No queue name is configured");
}
}
return(errorMessages);
}
private static void AssertPostgreSqlMetricDefinition(MetricDefinition deserializedPostgreSqlMetricDefinition, PostgreSqlMetricDefinitionV1 postgreSqlMetricDefinition)
{
var deserializedResource = deserializedPostgreSqlMetricDefinition.Resources.Single() as PostgreSqlResourceDefinition;
Assert.NotNull(deserializedResource);
Assert.Equal(postgreSqlMetricDefinition.ServerName, deserializedResource.ServerName);
}
private static void AssertCosmosDbMetricDefinition(MetricDefinition deserializedCosmosDbMetricDefinition, CosmosDbMetricDefinitionV1 cosmosDbMetricDefinition)
{
var deserializedResource = deserializedCosmosDbMetricDefinition.Resources.Single() as CosmosDbResourceDefinition;
Assert.NotNull(deserializedResource);
Assert.Equal(cosmosDbMetricDefinition.DbName, deserializedResource.DbName);
}
private async Task ScrapeMetric(AzureMetadata azureMetadata, MetricDefinition metricDefinitionDefinition)
{
Console.WriteLine($"\t> Scraping {metricDefinitionDefinition.Name} of type {metricDefinitionDefinition.ResourceType}");
var scraper = MetricScraperFactory.CreateScraper(azureMetadata, metricDefinitionDefinition.ResourceType);
await scraper.ScrapeAsync(metricDefinitionDefinition);
}
public IEnumerable <string> Validate(MetricDefinition metricDefinition)
{
Guard.NotNull(metricDefinition, nameof(metricDefinition));
var errorMessages = new List <string>();
var configuredDimension = metricDefinition.AzureMetricConfiguration?.Dimension?.Name;
var isEntityNameDimensionConfigured = string.IsNullOrWhiteSpace(configuredDimension) == false && configuredDimension.Equals(EntityNameDimension, StringComparison.InvariantCultureIgnoreCase);
foreach (var resourceDefinition in metricDefinition.Resources.Cast <ServiceBusNamespaceResourceDefinition>())
{
if (string.IsNullOrWhiteSpace(resourceDefinition.Namespace))
{
errorMessages.Add("No Service Bus Namespace is configured");
}
if (isEntityNameDimensionConfigured && string.IsNullOrWhiteSpace(resourceDefinition.QueueName) == false)
{
errorMessages.Add($"Queue name is configured while '{EntityNameDimension}' dimension is configured as well. We only support one or the other.");
}
if (isEntityNameDimensionConfigured && string.IsNullOrWhiteSpace(resourceDefinition.TopicName) == false)
{
errorMessages.Add($"Topic name is configured while '{EntityNameDimension}' dimension is configured as well. We only support one or the other.");
}
if (string.IsNullOrWhiteSpace(resourceDefinition.QueueName) == false && string.IsNullOrWhiteSpace(resourceDefinition.TopicName) == false)
{
errorMessages.Add("Queue & topic name are both configured while we only support one or the other.");
}
}
return(errorMessages);
}
protected void AssertMetricDefinition(MetricDefinition deserializedMetricDefinition, MetricDefinitionV1 metricDefinition)
{
Assert.NotNull(deserializedMetricDefinition);
Assert.NotNull(deserializedMetricDefinition.PrometheusMetricDefinition);
Assert.Equal(metricDefinition.Name, deserializedMetricDefinition.PrometheusMetricDefinition.Name);
Assert.Equal(metricDefinition.Description, deserializedMetricDefinition.PrometheusMetricDefinition.Description);
Assert.Equal(metricDefinition.ResourceType, deserializedMetricDefinition.ResourceType);
Assert.NotNull(deserializedMetricDefinition.PrometheusMetricDefinition.Labels);
Assert.Equal(metricDefinition.Labels, deserializedMetricDefinition.PrometheusMetricDefinition.Labels);
Assert.NotEmpty(deserializedMetricDefinition.Resources);
Assert.Equal(deserializedMetricDefinition.Resources.Single().ResourceGroupName, metricDefinition.ResourceGroupName);
foreach (var label in metricDefinition.Labels)
{
var deserializedLabel = deserializedMetricDefinition.PrometheusMetricDefinition.Labels[label.Key];
Assert.NotNull(deserializedLabel);
Assert.Equal(label.Value, deserializedLabel);
}
Assert.NotNull(deserializedMetricDefinition.AzureMetricConfiguration);
Assert.Equal(metricDefinition.AzureMetricConfiguration.MetricName, deserializedMetricDefinition.AzureMetricConfiguration.MetricName);
Assert.NotNull(deserializedMetricDefinition.AzureMetricConfiguration.Aggregation);
Assert.Equal(metricDefinition.AzureMetricConfiguration.Aggregation.Type, deserializedMetricDefinition.AzureMetricConfiguration.Aggregation.Type);
Assert.Equal(metricDefinition.AzureMetricConfiguration.Aggregation.Interval, deserializedMetricDefinition.AzureMetricConfiguration.Aggregation.Interval);
}
private IList <string> Validate(MetricDefinition metric)
{
Guard.NotNull(metric, nameof(metric));
var errorMessages = new List <string>();
if (metric == null)
{
errorMessages.Add("Invalid metric is configured");
return(errorMessages);
}
if (metric.ResourceType == ResourceType.NotSpecified)
{
errorMessages.Add($"{metric.ResourceType} '{nameof(ResourceType.NotSpecified)}' is not supported");
}
if (string.IsNullOrWhiteSpace(metric.Name))
{
errorMessages.Add("No metric name is configured");
}
var metricDefinitionValidationErrors = MetricValidatorFactory
.GetValidatorFor(metric.ResourceType)
.Validate(metric);
errorMessages.AddRange(metricDefinitionValidationErrors);
var metricAggregationValidator = new AzureMetricConfigurationValidator(_metricDefaults);
var metricsConfigurationErrorMessages = metricAggregationValidator.Validate(metric.AzureMetricConfiguration);
errorMessages.AddRange(metricsConfigurationErrorMessages);
return(errorMessages);
}
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 bool SupportsRequestedDimensions(MetricDefinition definition, MetricFilter filter)
{
MetricDimension metric = filter.DimensionFilters.FirstOrDefault(df => string.Equals(df.Name, definition.Name.Value, StringComparison.OrdinalIgnoreCase));
var supportedDimensionNames = definition.Dimensions.Select(dim => dim.Name);
var supportedDimensionValues = definition.Dimensions.ToDictionary(dim => dim.Name.Value, dim => dim.Values.Select(v => v.Value));
// No dimensions specified for this metric
if (metric == null || metric.Dimensions == null)
{
return(true);
}
foreach (MetricFilterDimension dimension in metric.Dimensions)
{
// find dimension in definition
Dimension d = definition.Dimensions.FirstOrDefault(dim => string.Equals(dim.Name.Value, dimension.Name));
// Dimension name does't show up in definition
if (d == null)
{
return(false);
}
// Requested dimension has any value that don't show up in the values list for the definiton
if (dimension.Values.Any(value => !d.Values.Select(v => v.Value).Contains(value, StringComparer.OrdinalIgnoreCase)))
{
return(false);
}
}
return(true);
}
public IEnumerable <string> Validate(MetricDefinition metricDefinition)
{
Guard.NotNull(metricDefinition, nameof(metricDefinition));
foreach (var resourceDefinition in metricDefinition.Resources.Cast <StorageQueueResourceDefinition>())
{
if (string.IsNullOrWhiteSpace(resourceDefinition.AccountName))
{
yield return("No Azure Storage Account Name is configured");
}
if (string.IsNullOrWhiteSpace(resourceDefinition.QueueName))
{
yield return("No Azure Storage Queue Name is configured");
}
var configuredSasToken = resourceDefinition.SasToken?.GetSecretValue();
if (string.IsNullOrWhiteSpace(configuredSasToken))
{
yield return("No Azure Storage SAS Token is configured");
}
if (!_validMetricNames.Any(metricName => metricName.Equals(metricDefinition.AzureMetricConfiguration.MetricName, StringComparison.InvariantCultureIgnoreCase)))
{
yield return($"Invalid metric name {metricDefinition.AzureMetricConfiguration.MetricName}");
}
}
}
public async Task Should_NOT_get_AssetDefinition()
{
//Arrange
// Build the AssetDefinition
var assetDefinition = new AssetDefinition()
{
Name = AssetDefinitionName,
Url = AssetDefinitionUrl,
};
var metricDefinitions = new MetricDefinition[]
{
new MetricDefinition {
Name = "Assay", Default = "0.9999", UnitOfMeasure = "Fineness", Description = "A Bar of Gold", SampleValue = "0.9999", Regex = @"^0([.,])\d+"
},
new MetricDefinition {
Name = "Bar Serial #", Description = "The serial number of the bar of gold", SampleValue = "123456", UnitOfMeasure = "Identifier"
}
};
assetDefinition.MetricDefinitions = metricDefinitions;
await InsertAsync(assetDefinition);
var getAssetDefinitionRequest = new GetAssetDefinitionRequest
{
AssetDefinitionId = assetDefinition.AssetDefinitionId + 1
};
//Act
GetAssetDefinitionResponse getAssetDefinitionResponse = await SendAsync(getAssetDefinitionRequest);
//Assert
getAssetDefinitionResponse.AssetDefinition.ShouldBeNull();
}
public void MetricCollectionFindByIndex()
{
MetricDefinition testMetricDefinition = GetTestMetricDefinition();
IMetric testMetric = testMetricDefinition.Metrics[0];
Assert.IsNotNull(testMetric);
}
private static void AssertServiceBusQueueMetricDefinition(MetricDefinition deserializedServiceBusMetricDefinition, ServiceBusQueueMetricDefinitionV1 serviceBusMetricDefinition)
{
var deserializedResource = deserializedServiceBusMetricDefinition.Resources.Single() as ServiceBusQueueResourceDefinition;
Assert.NotNull(deserializedResource);
Assert.Equal(serviceBusMetricDefinition.Namespace, deserializedResource.Namespace);
Assert.Equal(serviceBusMetricDefinition.QueueName, deserializedResource.QueueName);
}
public void MetricCollectionStringKeyMiss()
{
Assert.Throws <KeyNotFoundException>(() =>
{
MetricDefinition testMetricDefinition = GetTestMetricDefinition();
IMetric testMetric = testMetricDefinition.Metrics["ThisKeyShouldNeverBeHere"];
});
}
public void MetricCollectionOverrun()
{
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
MetricDefinition testMetricDefinition = GetTestMetricDefinition();
IMetric testMetric = testMetricDefinition.Metrics[-1];
});
}
public void MetricCollectionFindByGuidKey()
{
MetricDefinition testMetricDefinition = GetTestMetricDefinition();
IMetric lookupMetric = testMetricDefinition.Metrics[0]; //this test we already passed, so now we use it to do the rest of our tests.
IMetric testMetric = testMetricDefinition.Metrics[lookupMetric.Id];
Assert.IsNotNull(testMetric);
}
public void MetricCollectionGuidKeyMiss()
{
Assert.Throws <KeyNotFoundException>(() =>
{
MetricDefinition testMetricDefinition = GetTestMetricDefinition();
IMetric testMetric = testMetricDefinition.Metrics[Guid.NewGuid()];
});
}
private IEnumerable <Metrics> GetManagerMetrics(MetricDefinition metricDefinition)
{
var managerMetrics = this.Client.Managers.ListMetrics(
GenerateOdataFilterForMetric(metricDefinition),
this.ResourceGroupName,
this.ManagerName);
return(managerMetrics);
}
private void SanitizeStorageQueueDeclaration(MetricDefinition metricDefinition)
{
var storageQueueDeclaration = metricDefinition as StorageQueueMetricDefinition;
if (storageQueueDeclaration != null && string.IsNullOrWhiteSpace(storageQueueDeclaration.SasToken.RawValue) == false)
{
storageQueueDeclaration.SasToken.RawValue = "***";
}
}
public void MetricDefinition_WithoutUnit_Returns_ValidJson()
{
MetricDefinition metricDefinition = new MetricDefinition("Time");
string metricString = JsonConvert.SerializeObject(metricDefinition);
Assert.Equal("{\"Name\":\"Time\",\"Unit\":\"None\"}", metricString);
Assert.Empty(metricDefinition.Values);
}
private string[] GetInstanceNames(MetricDefinition def)
{
if (!string.IsNullOrEmpty(def.InstanceFilter))
{
return(new string[] { def.InstanceFilter });
}
return(null);
}
private async Task ScrapeMetric(AzureMetadata azureMetadata, MetricDefinition metricDefinitionDefinition)
{
_logger.LogInformation("Scraping '{MetricName}' for resource type '{ResourceType}'", metricDefinitionDefinition.Name, metricDefinitionDefinition.ResourceType);
var scraper = MetricScraperFactory.CreateScraper(metricDefinitionDefinition.ResourceType, azureMetadata, _logger, _exceptionTracker);
int subscriptionReadLimit = await scraper.ScrapeAsync(metricDefinitionDefinition);
HealthMonitor.Instance.setSubscriptionLimitCount(subscriptionReadLimit);
}
public void MetricDefinitionObjectLookup()
{
MetricDefinition lookupMetricDefinition = GetTestMetricDefinition();
//look it up by GUID
Assert.AreSame(lookupMetricDefinition, Log.Metrics[lookupMetricDefinition.Id], "Failed to find same object when looking by Id");
Assert.AreSame(lookupMetricDefinition, Log.Metrics[lookupMetricDefinition.Name], "Failed to find same object when looking by Name");
Assert.AreSame(lookupMetricDefinition, Log.Metrics[lookupMetricDefinition.MetricTypeName, lookupMetricDefinition.CategoryName, lookupMetricDefinition.CounterName], "Failed to find same object when looking by Key Components");
}
/// <summary>
/// Initializes an new instance of the PSMetricDefinitionNoDetails class
/// </summary>
/// <param name="metricDefinition">The MetricDefinition</param>
public PSMetricDefinitionNoDetails(MetricDefinition metricDefinition)
{
// Keep the original value (localized string, Dictionary, List) in the base
base.Name = metricDefinition.Name;
this.MetricAvailabilities = metricDefinition.MetricAvailabilities;
this.Name = metricDefinition.Name == null ? null : metricDefinition.Name.Value;
this.PrimaryAggregationType = metricDefinition.PrimaryAggregationType;
this.Unit = metricDefinition.Unit;
}
public void MetricObjectLookup()
{
MetricDefinition lookupMetricDefinition = GetTestMetricDefinition();
Metric lookupMetric = GetTestMetric();
Assert.AreSame(lookupMetric, Log.Metrics.Metric(lookupMetric.Id), "Failed to find metric in Log.Metrics Metric cache");
Assert.AreSame(lookupMetric, lookupMetricDefinition.Metrics[lookupMetric.Id], "Failed to find same object when looking by Id");
Assert.AreSame(lookupMetric, lookupMetricDefinition.Metrics[lookupMetric.InstanceName], "Failed to find same object when looking by Instance Name");
Assert.AreSame(lookupMetric, lookupMetricDefinition.Metrics[lookupMetric.Name], "Failed to find same object when looking by Full Name");
}
/// <summary>
/// Initializes an new instance of the PSMetricDefinition class
/// </summary>
/// <param name="metricDefinition">The MetricDefinition</param>
public PSMetricDefinition(MetricDefinition metricDefinition) : base(metricDefinition)
{
this.MetricAvailabilities = new PSAvailabilityCollection(metricDefinition.MetricAvailabilities);
}
private string[] GetInstanceNames(MetricDefinition def)
{
if (!string.IsNullOrEmpty(def.InstanceFilter))
{
return new string[] { def.InstanceFilter };
}
return null;
}
