public async Task CreateMetricDescriptorAsync2()
{
Mock <MetricService.MetricServiceClient> mockGrpcClient = new Mock <MetricService.MetricServiceClient>(MockBehavior.Strict);
CreateMetricDescriptorRequest request = new CreateMetricDescriptorRequest
{
ProjectName = new ProjectName("[PROJECT]"),
MetricDescriptor = new MetricDescriptor(),
};
MetricDescriptor expectedResponse = new MetricDescriptor
{
Name = "name2-1052831874",
Type = "type3575610",
Unit = "unit3594628",
Description = "description-1724546052",
DisplayName = "displayName1615086568",
};
mockGrpcClient.Setup(x => x.CreateMetricDescriptorAsync(request, It.IsAny <CallOptions>()))
.Returns(new Grpc.Core.AsyncUnaryCall <MetricDescriptor>(Task.FromResult(expectedResponse), null, null, null, null));
MetricServiceClient client = new MetricServiceClientImpl(mockGrpcClient.Object, null);
MetricDescriptor response = await client.CreateMetricDescriptorAsync(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
// [START monitoring_create_metric]
public static object CreateMetric(string projectId,
string metricType = "custom.googleapis.com/stores/daily_sales")
{
// Create client.
MetricServiceClient metricServiceClient = MetricServiceClient.Create();
// Prepare custom metric descriptor.
MetricDescriptor metricDescriptor = new MetricDescriptor();
metricDescriptor.DisplayName = "Daily Sales";
metricDescriptor.Description = "Daily sales records from all branch stores.";
metricDescriptor.MetricKind = MetricKind.Gauge;
metricDescriptor.ValueType = MetricDescriptor.Types.ValueType.Double;
metricDescriptor.Type = metricType;
metricDescriptor.Unit = "{USD}";
LabelDescriptor labels = new LabelDescriptor();
labels.Key = "store_id";
labels.ValueType = LabelDescriptor.Types.ValueType.String;
labels.Description = "The ID of the store.";
metricDescriptor.Labels.Add(labels);
CreateMetricDescriptorRequest request = new CreateMetricDescriptorRequest
{
ProjectName = new ProjectName(projectId),
};
request.MetricDescriptor = metricDescriptor;
// Make the request.
MetricDescriptor response = metricServiceClient.CreateMetricDescriptor(request);
Console.WriteLine("Done creating metric descriptor:");
Console.WriteLine(JObject.Parse($"{response}").ToString());
return(0);
}
// Create a Metric using the TagKeys and TagValues.
/// <summary>
/// Generate Stackdriver Metric from Opencensus View
/// </summary>
/// <param name="view"></param>
/// <param name="tagValues"></param>
/// <param name="metricDescriptor">Stackdriver Metric Descriptor</param>
/// <param name="domain"></param>
/// <returns></returns>
public static Metric GetMetric(
IView view,
IList <ITagValue> tagValues,
MetricDescriptor metricDescriptor,
string domain)
{
var metric = new Metric();
metric.Type = metricDescriptor.Type;
IList <ITagKey> columns = view.Columns;
// Populate metric labels
for (int i = 0; i < tagValues.Count; i++)
{
ITagKey key = columns[i];
ITagValue value = tagValues[i];
if (value == null)
{
continue;
}
string labelKey = GetStackdriverLabelKey(key.Name);
metric.Labels.Add(labelKey, value.AsString);
}
metric.Labels.Add(Constants.OPENCENSUS_TASK, Constants.OPENCENSUS_TASK_VALUE_DEFAULT);
// TODO - zeltser - make sure all the labels from the metric descriptor were fulfilled
return(metric);
}
public void CreateMetricDescriptor()
{
Mock <MetricService.MetricServiceClient> mockGrpcClient = new Mock <MetricService.MetricServiceClient>(MockBehavior.Strict);
CreateMetricDescriptorRequest expectedRequest = new CreateMetricDescriptorRequest
{
ProjectName = new ProjectName("[PROJECT]"),
MetricDescriptor = new MetricDescriptor(),
};
MetricDescriptor expectedResponse = new MetricDescriptor
{
Name = "name2-1052831874",
Type = "type3575610",
Unit = "unit3594628",
Description = "description-1724546052",
DisplayName = "displayName1615086568",
};
mockGrpcClient.Setup(x => x.CreateMetricDescriptor(expectedRequest, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
MetricServiceClient client = new MetricServiceClientImpl(mockGrpcClient.Object, null);
ProjectName name = new ProjectName("[PROJECT]");
MetricDescriptor metricDescriptor = new MetricDescriptor();
MetricDescriptor response = client.CreateMetricDescriptor(name, metricDescriptor);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
// Create a Metric using the TagKeys and TagValues.
/// <summary>
/// Generate Stackdriver Metric from OpenTelemetry View.
/// </summary>
/// <param name="view">A <see cref="IView"/>.</param>
/// <param name="tagValues">A list of <see cref="TagValue"/>.</param>
/// <param name="metricDescriptor">Stackdriver Metric Descriptor.</param>
/// <param name="domain">The domain.</param>
/// <returns><see cref="Metric"/>.</returns>
public static Metric GetMetric(
IView view,
IReadOnlyList <TagValue> tagValues,
MetricDescriptor metricDescriptor,
string domain)
{
var metric = new Metric();
metric.Type = metricDescriptor.Type;
var columns = view.Columns;
// Populate metric labels
for (var i = 0; i < tagValues.Count; i++)
{
var key = columns[i];
var value = tagValues[i];
if (value == null)
{
continue;
}
var labelKey = GetStackdriverLabelKey(key.Name);
metric.Labels.Add(labelKey, value.AsString);
}
metric.Labels.Add(Constants.OpenTelemetryTask, Constants.OpenTelemetryTaskValueDefault);
// TODO - zeltser - make sure all the labels from the metric descriptor were fulfilled
return(metric);
}
public async Task <MetricDescriptor> CreateMetricAsync(MetricDescriptor metricDescriptor)
{
return(await _client.CreateMetricDescriptorAsync(new CreateMetricDescriptorRequest
{
ProjectName = _projectName,
MetricDescriptor = metricDescriptor
}));
}
/// <summary>Snippet for GetMetricDescriptor</summary>
public void GetMetricDescriptor()
{
// Snippet: GetMetricDescriptor(MetricDescriptorName,CallSettings)
// Create client
MetricServiceClient metricServiceClient = MetricServiceClient.Create();
// Initialize request argument(s)
MetricDescriptorName name = new MetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]");
// Make the request
MetricDescriptor response = metricServiceClient.GetMetricDescriptor(name);
// End snippet
}
/// <summary>Snippet for CreateMetricDescriptor</summary>
public void CreateMetricDescriptor()
{
// Snippet: CreateMetricDescriptor(ProjectName,MetricDescriptor,CallSettings)
// Create client
MetricServiceClient metricServiceClient = MetricServiceClient.Create();
// Initialize request argument(s)
ProjectName name = new ProjectName("[PROJECT]");
MetricDescriptor metricDescriptor = new MetricDescriptor();
// Make the request
MetricDescriptor response = metricServiceClient.CreateMetricDescriptor(name, metricDescriptor);
// End snippet
}
public async Task GetMetricDescriptorAsync()
{
// Snippet: GetMetricDescriptorAsync(string,CallSettings)
// Additional: GetMetricDescriptorAsync(string,CancellationToken)
// Create client
MetricServiceClient metricServiceClient = MetricServiceClient.Create();
// Initialize request argument(s)
string formattedName = MetricServiceClient.FormatMetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]");
// Make the request
MetricDescriptor response = await metricServiceClient.GetMetricDescriptorAsync(formattedName);
// End snippet
}
/// <summary>Snippet for GetMetricDescriptor</summary>
public void GetMetricDescriptor_RequestObject()
{
// Snippet: GetMetricDescriptor(GetMetricDescriptorRequest,CallSettings)
// Create client
MetricServiceClient metricServiceClient = MetricServiceClient.Create();
// Initialize request argument(s)
GetMetricDescriptorRequest request = new GetMetricDescriptorRequest
{
MetricDescriptorName = new MetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]"),
};
// Make the request
MetricDescriptor response = metricServiceClient.GetMetricDescriptor(request);
// End snippet
}
public async Task CreateMetricDescriptorAsync()
{
// Snippet: CreateMetricDescriptorAsync(string,MetricDescriptor,CallSettings)
// Additional: CreateMetricDescriptorAsync(string,MetricDescriptor,CancellationToken)
// Create client
MetricServiceClient metricServiceClient = MetricServiceClient.Create();
// Initialize request argument(s)
string formattedName = MetricServiceClient.FormatProjectName("[PROJECT]");
MetricDescriptor metricDescriptor = new MetricDescriptor();
// Make the request
MetricDescriptor response = await metricServiceClient.CreateMetricDescriptorAsync(formattedName, metricDescriptor);
// End snippet
}
/// <summary>Snippet for CreateMetricDescriptor</summary>
public void CreateMetricDescriptor_RequestObject()
{
// Snippet: CreateMetricDescriptor(CreateMetricDescriptorRequest,CallSettings)
// Create client
MetricServiceClient metricServiceClient = MetricServiceClient.Create();
// Initialize request argument(s)
CreateMetricDescriptorRequest request = new CreateMetricDescriptorRequest
{
ProjectName = new ProjectName("[PROJECT]"),
MetricDescriptor = new MetricDescriptor(),
};
// Make the request
MetricDescriptor response = metricServiceClient.CreateMetricDescriptor(request);
// End snippet
}
/// <summary>Snippet for GetMetricDescriptorAsync</summary>
public async Task GetMetricDescriptorAsync_RequestObject()
{
// Snippet: GetMetricDescriptorAsync(GetMetricDescriptorRequest,CallSettings)
// Additional: GetMetricDescriptorAsync(GetMetricDescriptorRequest,CancellationToken)
// Create client
MetricServiceClient metricServiceClient = await MetricServiceClient.CreateAsync();
// Initialize request argument(s)
GetMetricDescriptorRequest request = new GetMetricDescriptorRequest
{
MetricDescriptorName = new MetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]"),
};
// Make the request
MetricDescriptor response = await metricServiceClient.GetMetricDescriptorAsync(request);
// End snippet
}
/// <summary>Snippet for CreateMetricDescriptorAsync</summary>
public async Task CreateMetricDescriptorAsync_RequestObject()
{
// Snippet: CreateMetricDescriptorAsync(CreateMetricDescriptorRequest,CallSettings)
// Additional: CreateMetricDescriptorAsync(CreateMetricDescriptorRequest,CancellationToken)
// Create client
MetricServiceClient metricServiceClient = await MetricServiceClient.CreateAsync();
// Initialize request argument(s)
CreateMetricDescriptorRequest request = new CreateMetricDescriptorRequest
{
ProjectName = new ProjectName("[PROJECT]"),
MetricDescriptor = new MetricDescriptor(),
};
// Make the request
MetricDescriptor response = await metricServiceClient.CreateMetricDescriptorAsync(request);
// End snippet
}
/// <summary>
/// Convert ViewData to a list of TimeSeries, so that ViewData can be uploaded to Stackdriver.
/// </summary>
/// <param name="viewData">OpenTelemetry View.</param>
/// <param name="monitoredResource">Stackdriver Resource to which the metrics belong.</param>
/// <param name="metricDescriptor">Stackdriver Metric Descriptor.</param>
/// <param name="domain">The metrics domain (namespace).</param>
/// <returns><see cref="List{T}"/>.</returns>
public static List <TimeSeries> CreateTimeSeriesList(
IViewData viewData,
MonitoredResource monitoredResource,
MetricDescriptor metricDescriptor,
string domain)
{
var timeSeriesList = new List <TimeSeries>();
if (viewData == null)
{
return(timeSeriesList);
}
var view = viewData.View;
var startTime = viewData.Start.ToTimestamp();
// Each entry in AggregationMap will be converted into an independent TimeSeries object
foreach (var entry in viewData.AggregationMap)
{
var timeSeries = new TimeSeries();
var labels = entry.Key.Values;
var points = entry.Value;
timeSeries.Resource = monitoredResource;
timeSeries.ValueType = view.Measure.ToValueType(view.Aggregation);
timeSeries.MetricKind = view.Aggregation.ToMetricKind();
timeSeries.Metric = GetMetric(view, labels, metricDescriptor, domain);
var point = ExtractPointInInterval(viewData.Start, viewData.End, view.Aggregation, points);
var timeSeriesPoints = new List <Point> {
point
};
timeSeries.Points.AddRange(timeSeriesPoints);
timeSeriesList.Add(timeSeries);
}
return(timeSeriesList);
}
private void Export()
{
var viewDataList = new List <IViewData>();
foreach (var view in viewManager.AllExportedViews)
{
if (RegisterView(view))
{
var data = viewManager.GetView(view.Name);
viewDataList.Add(data);
}
}
// Add time series from all the views that need exporting
var timeSeriesList = new List <TimeSeries>();
foreach (var viewData in viewDataList)
{
MetricDescriptor metricDescriptor = metricDescriptors[viewData.View];
List <TimeSeries> timeSeries = MetricsConversions.CreateTimeSeriesList(viewData, monitoredResource, metricDescriptor, domain);
timeSeriesList.AddRange(timeSeries);
}
// Perform the operation in batches of MAX_BATCH_EXPORT_SIZE
foreach (IEnumerable <TimeSeries> batchedTimeSeries in timeSeriesList.Partition(MAX_BATCH_EXPORT_SIZE))
{
var request = new CreateTimeSeriesRequest();
request.ProjectName = project;
request.TimeSeries.AddRange(batchedTimeSeries);
try
{
metricServiceClient.CreateTimeSeries(request);
}
catch (RpcException e)
{
ExporterStackdriverEventSource.Log.UnknownProblemWhileCreatingStackdriverTimeSeriesError(e);
}
}
}
private bool EnsureMetricDescriptorExists(MetricDescriptor metricDescriptor)
{
try
{
var request = new CreateMetricDescriptorRequest();
request.ProjectName = project;
request.MetricDescriptor = metricDescriptor;
metricServiceClient.CreateMetricDescriptor(request);
}
catch (RpcException e)
{
// Metric already exists
if (e.StatusCode == StatusCode.AlreadyExists)
{
return(true);
}
return(false);
}
return(true);
}
/// <summary>
/// Creates Stackdriver MetricDescriptor from OpenTelemetry View.
/// </summary>
/// <param name="metricDescriptorTypeName">Metric Descriptor full type name.</param>
/// <param name="view">OpenTelemetry View.</param>
/// <param name="project">Google Cloud Project Name.</param>
/// <param name="domain">The Domain.</param>
/// <param name="displayNamePrefix">Display Name Prefix.</param>
/// <returns><see cref="MetricDescriptor"/>.</returns>
public static MetricDescriptor CreateMetricDescriptor(
string metricDescriptorTypeName,
IView view,
ProjectName project,
string domain,
string displayNamePrefix)
{
var metricDescriptor = new MetricDescriptor();
var viewName = view.Name.AsString;
metricDescriptor.Name = string.Format($"projects/{project.ProjectId}/metricDescriptors/{metricDescriptorTypeName}");
metricDescriptor.Type = metricDescriptorTypeName;
metricDescriptor.Description = view.Description;
metricDescriptor.DisplayName = GetDisplayName(viewName, displayNamePrefix);
foreach (var tagKey in view.Columns)
{
var labelDescriptor = tagKey.ToLabelDescriptor();
metricDescriptor.Labels.Add(labelDescriptor);
}
metricDescriptor.Labels.Add(
new LabelDescriptor
{
Key = Constants.OpenTelemetryTask,
Description = Constants.OpenTelemetryTaskDescription,
ValueType = LabelDescriptor.Types.ValueType.String,
});
var unit = GetUnit(view.Aggregation, view.Measure);
metricDescriptor.Unit = unit;
metricDescriptor.MetricKind = view.Aggregation.ToMetricKind();
metricDescriptor.ValueType = view.Measure.ToValueType(view.Aggregation);
return(metricDescriptor);
}
public void GetMetricDescriptor2()
{
Mock <MetricService.MetricServiceClient> mockGrpcClient = new Mock <MetricService.MetricServiceClient>(MockBehavior.Strict);
GetMetricDescriptorRequest request = new GetMetricDescriptorRequest
{
MetricDescriptorName = new MetricDescriptorName("[PROJECT]", "[METRIC_DESCRIPTOR]"),
};
MetricDescriptor expectedResponse = new MetricDescriptor
{
Name = "name2-1052831874",
Type = "type3575610",
Unit = "unit3594628",
Description = "description-1724546052",
DisplayName = "displayName1615086568",
};
mockGrpcClient.Setup(x => x.GetMetricDescriptor(request, It.IsAny <CallOptions>()))
.Returns(expectedResponse);
MetricServiceClient client = new MetricServiceClientImpl(mockGrpcClient.Object, null);
MetricDescriptor response = client.GetMetricDescriptor(request);
Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
private bool RegisterView(IView view)
{
IView existing = null;
if (registeredViews.TryGetValue(view.Name, out existing))
{
// Ignore views that are already registered.
return(existing.Equals(view));
}
registeredViews.Add(view.Name, view);
string metricDescriptorTypeName = GenerateMetricDescriptorTypeName(view.Name, domain);
// TODO - zeltser: don't need to create MetricDescriptor for RpcViewConstants once we defined
// canonical metrics. Registration is required only for custom view definitions. Canonical
// views should be pre-registered.
MetricDescriptor metricDescriptor = MetricsConversions.CreateMetricDescriptor(
metricDescriptorTypeName,
view,
project,
domain,
displayNamePrefix);
if (metricDescriptor == null)
{
// Don't register interval views in this version.
return(false);
}
// Cache metric descriptor and ensure it exists in Stackdriver
if (!metricDescriptors.ContainsKey(view))
{
metricDescriptors.Add(view, metricDescriptor);
}
return(EnsureMetricDescriptorExists(metricDescriptor));
}
public static Metric <T> WithValue <T>(this MetricDescriptor <T> descriptor, T value) => Metric.Create(descriptor, value);
public static Metric <T> WithoutValue <T>(this MetricDescriptor <T> descriptor) => Metric.Create(descriptor, EmptyValue <T>());
/// <summary>
/// Create a new metric.
/// Documentation https://developers.google.com/cloudmonitoring/v2beta2/reference/metricDescriptors/create
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Cloudmonitoring service.</param>
/// <param name="project">The project id. The value can be the numeric project ID or string-based project name.</param>
/// <param name="body">A valid Cloudmonitoring v2beta2 body.</param>
/// <returns>MetricDescriptorResponse</returns>
public static MetricDescriptor Create(CloudmonitoringService service, string project, MetricDescriptor body)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
if (project == null)
{
throw new ArgumentNullException(project);
}
// Make the request.
return(service.MetricDescriptors.Create(body, project).Execute());
}
catch (Exception ex)
{
throw new Exception("Request MetricDescriptors.Create failed.", ex);
}
}
