public TokenRequestContext (string[] scopes, string? parentRequestId = default, string? claims = default);
(https://docs.microsoft.com/dotnet/api/azure.core.tokenrequestcontext.-ctor).
public struct AccessToken
(https://docs.microsoft.com/dotnet/api/azure.core.accesstoken).
public abstract Azure.Core.AccessToken GetToken (Azure.Core.TokenRequestContext requestContext, System.Threading.CancellationToken cancellationToken).
(https://docs.microsoft.com/dotnet/api/azure.core.tokencredential.gettoken).
public abstract System.Threading.Tasks.ValueTask<Azure.Core.AccessToken> GetTokenAsync (Azure.Core.TokenRequestContext requestContext, System.Threading.CancellationToken cancellationToken);
(https://docs.microsoft.com/dotnet/api/azure.core.tokencredential.gettokenasync).
public abstract System.Threading.Tasks.ValueTask<Azure.Core.AccessToken> GetTokenAsync (Azure.Core.TokenRequestContext requestContext, System.Threading.CancellationToken cancellationToken);
(https://docs.microsoft.com/dotnet/api/azure.core.tokencredential.gettokenasync).
Contains constants used to refer to metric dimensions that will be mapped to fields
within the
When a metric has a dimension with this a name that equals to one of the constants defined here, the value of that
dimension will not be sent as a regular dimension-value, but as the value of the corresponding field within the telemetry
item's
The cube refers to dimensions using their index: 0th, 1st, 2nd dimension and so on. For each dimension, the cube has a
The elements of the coordinate vectors (i.e. the values of the dimensions of a point in the cube) are discrete. Even if their type implies a non-discrete space (e.g.when TDimensionValue is Double) they are always treated as discrete and separate.
The cube is designed to work in concurrent scenarios while minimizing the number, the duration and the scope of locks taken. However, some locks are necessary to correctly impose the SubdimensionsCountLimits and the TotalPointsCountLimit constrains.
This implementation assumes that creation and storage of TPoint-elements is resource intensive. It creates points lazily, only when requested. However, to minimize locking it uses pessimistic and optimistic concurrency mechanisms where possible. Two artifacts occur as a result:
** Color Example: **
An example of a cube is an RGB color space. Assume that we use 8 bits (= 256 values) per color and that is a color class such as this:
class Color
{
public Color(byte red, byte green, byte blue) { }
//...
}
It is possible to represent the entire space using a cube as follows:
Func{int[], Color} colorFactory = (rgbValues) =} new Color(red: rgbValues[0], green: rgbValues[1], blue: rgbValues[2]);
MultidimensionalCube{int, Color} colorCube = new MultidimensionalCube{int, Color}(colorFactory, 256, 256, 256);
We can now address specific color objects we follows:
MultidimensionalPointResult{Color} greenResult = colorCube.TryGetOrCreatePoint(0, 255, 0);
Color green = greenResult.Point;
MultidimensionalPointResult{Color} yellowResult = colorCube.TryGetOrCreatePoint(255, 255, 0);
Color yellow = yellowResult.Point;
MultidimensionalPointResult{Color} azureResult = colorCube.TryGetOrCreatePoint(0, 127, 255);
Color azure = azureResult.Point;
** Metrics Example: **
A multi-dimensional cube is used to address data time series of a multidimensional metric. Consider that we have a metric representing the number of milliseconds required to process a request to a web-service. We collect that metric according to a number of possible groupings:
Each view represents a separate dimension. There is a distinct data time series for each combination of dimension-values. For example:
So a data series representation might look like this:
class ResponseTimeMetricSeries
{
public ResponseTimeMetricSeries(string kind, string responseCode, string instanceName, string url) { }
//...
}
Note also that while some dimensions can naturally take a small amount of values(e.g.Type can only take 2 values in this example), URL can essentially take an unbounded number of values. In our example we want to limit the number of dimension values for specific dimensions in order to control resource usage. We can create a cube as follows. (Note how we used different max dimension values counts that are appropriate for each respective dimension.)
Func{string[], ResponseTimeMetricSeries} metricFactory = (dimValues) =} new ResponseTimeMetricSeries(
kind: dimValues[0],
responseCode: dimValues[1],
instanceName: dimValues[2],
url: dimValues[3]);
MultidimensionalCube{string, ResponseTimeMetricSeries} metricsCube = new MultidimensionalCube{string, ResponseTimeMetricSeries}(metricFactory, 2, 50, 100, 1000);
MultidimensionalPointResult{ResponseTimeMetricSeries} result;
result = metricsCube.TryGetOrCreatePoint("Organic", "200", "Instance_01", "http://myservice.com/API1?paramA=X");
if (! result.Success)
{
throw new SomeAppropriateException("Cannot create metric data series. Dimension cap is potentially reached.");
}
ResponseTimeMetricDataSeries responseSeries01 = result.Point;
result = metricsCube.TryGetOrCreatePoint("Organic", "500", "Instance_01", "http://myservice.com/API2?paramB=Y");
if (! result.Success)
{
throw new SomeAppropriateException("Cannot create metric data series. Dimension cap is potentially reached.");
}
ResponseTimeMetricSeries responseSeries02 = result.Point;
// receive message from a queue service (or any kind of the request/message from external service)
var message = queue.Receive();
// Extract tracing context from the message before processing it
// Note that some protocols may define how Activity should be serialized into the message,
// and some client SDKs implementing them may provide Extract method.
// For other protocols/libraries, serialization has to be agreed between producer and consumer
// and Inject/Extract pattern to be implemented
var activity = message.ExtractActivity();
// Track processing of the message
using (telemetryClient.StartOperation<RequestTelemetry>(activity))
{
// process message
}
// telemetry is reported when operation is disposed.