public void HandleStopEvent_RecordsStats()
{
var options = new MetricsOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new HttpClientDesktopObserver(options, stats, tags, null);
var req = GetHttpRequestMessage();
Activity act = new Activity("Test");
act.Start();
Thread.Sleep(1000);
act.SetEndTime(DateTime.UtcNow);
observer.HandleStopEvent(act, req, HttpStatusCode.InternalServerError);
observer.HandleStopEvent(act, req, HttpStatusCode.OK);
var reqData = stats.ViewManager.GetView(ViewName.Create("http.desktop.client.requests"));
var aggData1 = reqData.SumWithTags() as IDistributionData;
Assert.InRange(aggData1.Mean, 995.0, 1005.0);
Assert.InRange(aggData1.Max, 995.0, 1005.0);
reqData = stats.ViewManager.GetView(ViewName.Create("http.desktop.client.count"));
var aggData2 = reqData.SumWithTags() as ISumDataLong;
Assert.Equal(2, aggData2.Sum);
act.Stop();
}
public OwinHostingObserver(IMetricsOptions options, IStats censusStats, ITags censusTags, ILogger <OwinHostingObserver> logger)
: base(OBSERVER_NAME, DIAGNOSTIC_NAME, options, censusStats, censusTags, logger)
{
PathMatcher = new Regex(options.IngressIgnorePattern);
responseTimeMeasure = MeasureDouble.Create("server.owin.totalTime", "Total request time", MeasureUnit.MilliSeconds);
serverCountMeasure = MeasureLong.Create("server.owin.totalRequests", "Total request count", "count");
var view = View.Create(
ViewName.Create("http.server.request.time"),
"Total request time",
responseTimeMeasure,
Distribution.Create(BucketBoundaries.Create(new List <double>()
{
0.0, 1.0, 5.0, 10.0, 100.0
})),
new List <ITagKey>()
{
statusTagKey, exceptionTagKey, methodTagKey, uriTagKey
});
ViewManager.RegisterView(view);
view = View.Create(
ViewName.Create("http.server.request.count"),
"Total request counts",
serverCountMeasure,
Sum.Create(),
new List <ITagKey>()
{
statusTagKey, exceptionTagKey, methodTagKey, uriTagKey
});
ViewManager.RegisterView(view);
}
public void CreateMetrics_CountAgg_ReturnsExpected()
{
var opts = new CloudFoundryForwarderOptions();
var stats = new OpenCensusStats();
var tagsComponent = new TagsComponent();
var tagger = tagsComponent.Tagger;
var ep = new MicrometerMetricWriter(opts, stats);
IMeasureDouble testMeasure = MeasureDouble.Create("test.total", "test", MeasureUnit.Bytes);
SetupTestView(stats, Count.Create(), testMeasure, "test.test1");
ITagContext context1 = tagger
.EmptyBuilder
.Put(TagKey.Create("a"), TagValue.Create("v1"))
.Put(TagKey.Create("b"), TagValue.Create("v1"))
.Put(TagKey.Create("c"), TagValue.Create("v1"))
.Build();
long allKeyssum = 0;
for (int i = 0; i < 10; i++)
{
allKeyssum = allKeyssum + i;
stats.StatsRecorder.NewMeasureMap().Put(testMeasure, i).Record(context1);
}
var viewData = stats.ViewManager.GetView(ViewName.Create("test.test1"));
Assert.NotNull(viewData);
var aggMap = viewData.AggregationMap;
Assert.Single(aggMap);
var tagValues = aggMap.Keys.Single();
var data = aggMap.Values.Single();
Assert.NotNull(tagValues);
Assert.NotNull(data);
var result = ep.CreateMetrics(viewData, data, tagValues, 1L);
Assert.NotNull(result);
Assert.Single(result);
var metric = result[0];
Assert.Equal("test.test1", metric.Name);
Assert.Equal(1L, metric.Timestamp);
Assert.Equal("gauge", metric.Type);
Assert.Equal("bytes", metric.Unit);
Assert.Equal(10, metric.Value);
var tags = metric.Tags;
Assert.Equal("count", tags["statistic"]);
Assert.Equal("v1", tags["a"]);
Assert.Equal("v1", tags["b"]);
Assert.Equal("v1", tags["c"]);
}
public void Constructor_RegistersExpectedViews()
{
var options = new MetricsOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new AspNetCoreHostingObserver(options, stats, tags, null);
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("http.server.requests")));
}
public void HandleThreadsEvent_RecordsValues()
{
var options = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new CLRRuntimeObserver(options, stats, tags, null);
CLRRuntimeSource.ThreadMetrics metrics = new CLRRuntimeSource.ThreadMetrics(100, 100, 200, 200);
observer.HandleThreadsEvent(metrics);
var live = stats.ViewManager.GetView(ViewName.Create("clr.threadpool.active"));
var aggData = MetricsHelpers.SumWithTags(live) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(live, new List <ITagValue>()
{
TagValue.Create("worker")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(live, new List <ITagValue>()
{
TagValue.Create("completionPort")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
var avail = stats.ViewManager.GetView(ViewName.Create("clr.threadpool.avail"));
aggData = MetricsHelpers.SumWithTags(avail) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(avail, new List <ITagValue>()
{
TagValue.Create("worker")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
aggData = MetricsHelpers.SumWithTags(avail, new List <ITagValue>()
{
TagValue.Create("completionPort")
}) as IMeanData;
Assert.Equal(100, aggData.Mean);
Assert.Equal(100, aggData.Min);
Assert.Equal(100, aggData.Max);
}
public void Constructor_RegistersExpectedViews()
{
var options = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new HttpClientDesktopObserver(options, stats, tags, null);
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("http.desktop.client.request.time")));
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("http.desktop.client.request.count")));
}
public void PreventTooLongViewName()
{
char[] chars = new char[ViewName.NAME_MAX_LENGTH + 1];
for (int i = 0; i < chars.Length; i++)
{
chars[i] = 'a';
}
String longName = new String(chars);
Assert.Throws <ArgumentOutOfRangeException>(() => ViewName.Create(longName));
}
public void Constructor_RegistersExpectedViews()
{
var options = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tags = new OpenCensusTags();
var observer = new CLRRuntimeObserver(options, stats, tags, null);
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.memory.used")));
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.gc.collections")));
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.threadpool.active")));
Assert.NotNull(stats.ViewManager.GetView(ViewName.Create("clr.threadpool.avail")));
}
private static void ConfigureOpencensus(string zipkinUri, string appInsightsKey)
{
//if we want to have multiple tracers
//we should use agent mode and send first to agent
var ocExp = new OpenCensus.Exporter.Ocagent.OcagentExporter(
Tracing.ExportComponent
, "http://localhost:55678"
, Environment.MachineName
, "distributedtracingdemo"
);
ocExp.Start();
if (!string.IsNullOrEmpty(zipkinUri))
{
var zipK = new ZipkinTraceExporter(
new ZipkinTraceExporterOptions()
{
Endpoint = new Uri(zipkinUri),
ServiceName = "tracing-to-zipkin-service",
},
Tracing.ExportComponent
);
zipK.Start();
}
if (!string.IsNullOrEmpty(appInsightsKey))
{
var config = new TelemetryConfiguration(appInsightsKey);
var appI = new ApplicationInsightsExporter(
Tracing.ExportComponent,
Stats.ViewManager,
config);
appI.Start();
}
//Metrics
//define the measure to be used
// context fields defined, that will be attached
var invokeView = View.Create(ViewName.Create("executioncounts"), "Number of execs", numberofInvocations, Count.Create(), new[] { tagEnv, tagMachine });
//register
Stats.ViewManager.RegisterView(invokeView);
// 2. Configure 100% sample rate for the purposes of the demo
ITraceConfig traceConfig = Tracing.TraceConfig;
ITraceParams currentConfig = traceConfig.ActiveTraceParams;
var newConfig = currentConfig.ToBuilder()
.SetSampler(Samplers.AlwaysSample)
.Build();
traceConfig.UpdateActiveTraceParams(newConfig);
}
private string viewNameValidate(string str)
{
try
{
Model.ViewName.Value = ViewName.Create(str);
return(null);
}
catch (Exception ex)
{
Model.ViewName.Value = ViewName.NullObject;
return(ex.Message);
}
}
public void PreventTooLongViewName()
{
var chars = new char[ViewName.NameMaxLength + 1];
for (var i = 0; i < chars.Length; i++)
{
chars[i] = 'a';
}
var longName = new String(chars);
Assert.Throws <ArgumentOutOfRangeException>(() => ViewName.Create(longName));
}
protected internal MetricsResponse GetMetric(MetricsRequest request)
{
var viewData = _stats.ViewManager.GetView(ViewName.Create(request.MetricName));
if (viewData == null)
{
return(null);
}
List <MetricSample> measurements = GetMetricMeasurements(viewData, request.Tags);
List <MetricTag> availTags = GetAvailableTags(viewData);
return(new MetricsResponse(request.MetricName, measurements, availTags));
}
protected internal void RegisterViews()
{
IView view = View.Create(
ViewName.Create("clr.memory.used"),
"Current CLR memory usage",
memoryUsedMeasure,
Mean.Create(),
new List <ITagKey>()
{
memoryAreaKey
});
ViewManager.RegisterView(view);
view = View.Create(
ViewName.Create("clr.gc.collections"),
"Garbage collection count",
collectionCountMeasure,
Sum.Create(),
new List <ITagKey>()
{
generationKey
});
ViewManager.RegisterView(view);
view = View.Create(
ViewName.Create("clr.threadpool.active"),
"Active thread count",
activeThreadsMeasure,
Mean.Create(),
new List <ITagKey>()
{
threadKindKey
});
ViewManager.RegisterView(view);
view = View.Create(
ViewName.Create("clr.threadpool.avail"),
"Available thread count",
availThreadsMeasure,
Mean.Create(),
new List <ITagKey>()
{
threadKindKey
});
ViewManager.RegisterView(view);
}
private void SetupStats(OpenCensusStats stats)
{
var exceptionKey = TagKey.Create("exception");
var methodKey = TagKey.Create("method");
var uriKey = TagKey.Create("uri");
var statusKey = TagKey.Create("status");
var httpServerRquestMeasure = MeasureDouble.Create("server.totalTime", "server request times", MeasureUnit.MilliSeconds);
var httpServerRequestsViewName = ViewName.Create("http.server.requests");
var httpServerRequestsView = View.Create(
httpServerRequestsViewName,
"server request times",
httpServerRquestMeasure,
Distribution.Create(BucketBoundaries.Create(new List <double>()
{
0.0, 1.0, 2.0
})),
new List <ITagKey>()
{
exceptionKey, methodKey, uriKey, statusKey
});
stats.ViewManager.RegisterView(httpServerRequestsView);
var area = TagKey.Create("area");
var id = TagKey.Create("id");
var memoryUsageMeasure = MeasureDouble.Create("memory.value", "memory usage", MeasureUnit.Bytes);
var memoryUsageName = ViewName.Create("jvm.memory.used");
var memoryUsageView = View.Create(
memoryUsageName,
"memory usage",
memoryUsageMeasure,
Distribution.Create(BucketBoundaries.Create(new List <double>()
{
0.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0
})),
new List <ITagKey>()
{
area, id
});
stats.ViewManager.RegisterView(memoryUsageView);
}
public void GetAllExportedViews_ResultIsUnmodifiable()
{
IViewManager viewManager = NoopStats.NewNoopViewManager();
IView view1 =
View.Create(
ViewName.Create("View 1"), VIEW_DESCRIPTION, MEASURE, AGGREGATION, new List <ITagKey> {
KEY
});
viewManager.RegisterView(view1);
ISet <IView> exported = viewManager.AllExportedViews;
IView view2 =
View.Create(
ViewName.Create("View 2"), VIEW_DESCRIPTION, MEASURE, AGGREGATION, new List <ITagKey> {
KEY
});
Assert.Throws <NotSupportedException>(() => exported.Add(view2));
}
private void SetupTestView(OpenCensusStats stats)
{
var tagsComponent = new TagsComponent();
var tagger = tagsComponent.Tagger;
ITagKey aKey = TagKey.Create("a");
ITagKey bKey = TagKey.Create("b");
ITagKey cKey = TagKey.Create("c");
string viewName = "test.test";
IMeasureDouble measure = MeasureDouble.Create(Guid.NewGuid().ToString(), "test", MeasureUnit.Bytes);
IViewName testViewName = ViewName.Create(viewName);
IView testView = View.Create(
testViewName,
"test",
measure,
Sum.Create(),
new List <ITagKey>()
{
aKey, bKey, cKey
});
stats.ViewManager.RegisterView(testView);
ITagContext context1 = tagger
.EmptyBuilder
.Put(TagKey.Create("a"), TagValue.Create("v1"))
.Put(TagKey.Create("b"), TagValue.Create("v1"))
.Put(TagKey.Create("c"), TagValue.Create("v1"))
.Build();
for (int i = 0; i < 10; i++)
{
stats.StatsRecorder.NewMeasureMap().Put(measure, i).Record(context1);
}
}
public void SetupTestView(OpenCensusStats stats, IAggregation agg, IMeasure measure = null, string viewName = "test.test")
{
ITagKey aKey = TagKey.Create("a");
ITagKey bKey = TagKey.Create("b");
ITagKey cKey = TagKey.Create("c");
if (measure == null)
{
measure = MeasureDouble.Create(Guid.NewGuid().ToString(), "test", MeasureUnit.Bytes);
}
IViewName testViewName = ViewName.Create(viewName);
IView testView = View.Create(
testViewName,
"test",
measure,
agg,
new List <ITagKey>()
{
aKey, bKey, cKey
});
stats.ViewManager.RegisterView(testView);
}
private void SetupTestView(OpenCensusStats stats, IAggregation agg, IMeasure measure = null, string viewName = "test.test")
{
var aKey = TagKey.Create("a");
var bKey = TagKey.Create("b");
var cKey = TagKey.Create("c");
if (measure == null)
{
measure = MeasureDouble.Create(Guid.NewGuid().ToString(), "test", MeasureUnit.MilliSeconds);
}
var testViewName = ViewName.Create(viewName);
var testView = View.Create(
testViewName,
"test",
measure,
agg,
new List <ITagKey>()
{
aKey, bKey, cKey
});
stats.ViewManager.RegisterView(testView);
}
public void PreventNullNameString()
{
Assert.Throws <ArgumentNullException>(() => ViewName.Create(null));
}
public void PreventNonPrintableViewName()
{
Assert.Throws <ArgumentOutOfRangeException>(() => ViewName.Create("\u0002"));
}
public void TestViewName()
{
Assert.Equal("my name", ViewName.Create("my name").AsString);
}
private static IViewName CreateRandomViewName()
{
return(ViewName.Create(RandomString(RANDOM_NAME_LEN)));
}
public MessageBrokerViewModel(IEventAggregator eventAggregator)
{
MessageBrokerCommand.Subscribe(_ => Reactive.Bindings.Notifiers.MessageBroker.Default.Publish <SampleNameChange>(new SampleNameChange(SampleName.Create(MessageBrokerName.Value), ViewName.Create("MessageBrokerView")))).AddTo(DisposeCollection);
PubSubEventCommand.Subscribe(_ => eventAggregator.GetEvent <SampleNameChangeEvent>().Publish(new SampleNameChange(SampleName.Create(MessageBrokerName.Value), ViewName.Create("MessageBrokerView")))).AddTo(DisposeCollection);
}
public OpenTelemetryCollectorLogger(IStatsRecorder statsRecorder, ITagger tagger, ITagContext defaultTags = null)
{
this.statsRecorder = statsRecorder;
this.tagger = tagger;
// configure defaultTags included as default tag
this.defaultTags = defaultTags ?? TagContext.Empty;
if (defaultTags != TagContext.Empty)
{
foreach (var tag in defaultTags)
{
TagKeys.Add(tag.Key);
}
}
// Create Views
var buildServiceDefinitionView = View.Create(
name: ViewName.Create(BuildServiceDefinitionName),
description: "Build ServiceDefinition elapsed time(ms)",
measure: BuildServiceDefinition,
aggregation: Sum.Create(),
columns: TagKeys);
var unaryRequestCountView = View.Create(
name: ViewName.Create(UnaryRequestCountName),
description: "Request count for Unary request.",
measure: UnaryRequestCount,
aggregation: Sum.Create(),
columns: TagKeys);
var unaryResponseSizeView = View.Create(
name: ViewName.Create(UnaryResponseSizeName),
description: "Response size for Unary response.",
measure: UnaryResponseSize,
aggregation: Sum.Create(),
columns: TagKeys);
var unaryErrorCountView = View.Create(
name: ViewName.Create(UnaryErrorCountName),
description: "Error count for Unary request.",
measure: UnaryErrorCount,
aggregation: Sum.Create(),
columns: TagKeys);
var unaryElapsedView = View.Create(
name: ViewName.Create(UnaryElapsedName),
description: "Elapsed time for Unary request.",
measure: UnaryElapsed,
aggregation: Sum.Create(),
columns: TagKeys);
var streamingHubErrorCountView = View.Create(
name: ViewName.Create(StreamingHubErrorCountName),
description: "Error count for Streaminghub request.",
measure: StreamingHubErrorCount,
aggregation: Sum.Create(),
columns: TagKeys);
var streamingHubElapsedView = View.Create(
name: ViewName.Create(StreamingHubElapsedName),
description: "Elapsed time for Streaminghub request.",
measure: StreamingHubElapsed,
aggregation: Sum.Create(),
columns: TagKeys);
var streamingHubRequestCountView = View.Create(
name: ViewName.Create(StreamingHubRequestCountName),
description: "Request count for Streaminghub request.",
measure: StreamingHubRequestCount,
aggregation: Sum.Create(),
columns: TagKeys);
var streamingHubResponseSizeView = View.Create(
name: ViewName.Create(StreamingHubResponseSizeName),
description: "Response size for Streaminghub request.",
measure: StreamingHubResponseSize,
aggregation: Sum.Create(),
columns: TagKeys);
var connectCountView = View.Create(
name: ViewName.Create(ConnectCountName),
description: "Connect count for Streaminghub request. ConnectCount - DisconnectCount = current connect count. (successfully disconnected)",
measure: ConnectCount,
aggregation: Sum.Create(),
columns: TagKeys);
var disconnectCountView = View.Create(
name: ViewName.Create(DisconnectCountName),
description: "Disconnect count for Streaminghub request. ConnectCount - DisconnectCount = current connect count. (successfully disconnected)",
measure: DisconnectCount,
aggregation: Sum.Create(),
columns: TagKeys);
// Register Views
Stats.ViewManager.RegisterView(buildServiceDefinitionView);
Stats.ViewManager.RegisterView(unaryRequestCountView);
Stats.ViewManager.RegisterView(unaryResponseSizeView);
Stats.ViewManager.RegisterView(unaryErrorCountView);
Stats.ViewManager.RegisterView(unaryElapsedView);
Stats.ViewManager.RegisterView(connectCountView);
Stats.ViewManager.RegisterView(disconnectCountView);
Stats.ViewManager.RegisterView(streamingHubRequestCountView);
Stats.ViewManager.RegisterView(streamingHubResponseSizeView);
Stats.ViewManager.RegisterView(streamingHubErrorCountView);
Stats.ViewManager.RegisterView(streamingHubElapsedView);
}
public void Main()
{
var statsComponent = new StatsComponent();
var viewManager = statsComponent.ViewManager;
var statsRecorder = statsComponent.StatsRecorder;
var tagsComponent = new TagsComponent();
var tagger = tagsComponent.Tagger;
ITagKey FRONTEND_KEY = TagKey.Create("my.org/keys/frontend");
ITagKey FRONTEND_OS_KEY = TagKey.Create("my.org/keys/frontend/os");
ITagKey FRONTEND_OS_VERSION_KEY = TagKey.Create("my.org/keys/frontend/os/version");
IMeasureLong VIDEO_SIZE = MeasureLong.Create("my.org/measure/video_size", "size of processed videos", "MBy");
IViewName VIDEO_SIZE_BY_FRONTEND_VIEW_NAME = ViewName.Create("my.org/views/video_size_byfrontend");
IView VIDEO_SIZE_BY_FRONTEND_VIEW = View.Create(
VIDEO_SIZE_BY_FRONTEND_VIEW_NAME,
"processed video size over time",
VIDEO_SIZE,
Distribution.Create(BucketBoundaries.Create(new List <double>()
{
0.0, 256.0, 65536.0
})),
new List <ITagKey>()
{
FRONTEND_KEY
});
IViewName VIDEO_SIZE_ALL_VIEW_NAME = ViewName.Create("my.org/views/video_size_all");
IView VIDEO_SIZE_VIEW_ALL = View.Create(
VIDEO_SIZE_ALL_VIEW_NAME,
"processed video size over time",
VIDEO_SIZE,
Distribution.Create(BucketBoundaries.Create(new List <double>()
{
0.0, 256.0, 65536.0
})),
new List <ITagKey>()
{
});
IViewName VIDEO_SIZE_TOTAL_VIEW_NAME = ViewName.Create("my.org/views/video_size_total");
IView VIDEO_SIZE_TOTAL = View.Create(
VIDEO_SIZE_TOTAL_VIEW_NAME,
"total video size over time",
VIDEO_SIZE,
Sum.Create(),
new List <ITagKey>()
{
FRONTEND_KEY
});
IViewName VIDEOS_PROCESSED_VIEW_NAME = ViewName.Create("my.org/views/videos_processed");
IView VIDEOS_PROCESSED = View.Create(
VIDEOS_PROCESSED_VIEW_NAME,
"total video processed",
VIDEO_SIZE,
Count.Create(),
new List <ITagKey>()
{
FRONTEND_KEY
});
viewManager.RegisterView(VIDEO_SIZE_VIEW_ALL);
viewManager.RegisterView(VIDEO_SIZE_BY_FRONTEND_VIEW);
viewManager.RegisterView(VIDEO_SIZE_TOTAL);
viewManager.RegisterView(VIDEOS_PROCESSED);
ITagContext context1 = tagger
.EmptyBuilder
.Put(FRONTEND_KEY, TagValue.Create("front1"))
.Build();
ITagContext context2 = tagger
.EmptyBuilder
.Put(FRONTEND_KEY, TagValue.Create("front2"))
.Build();
long sum = 0;
for (int i = 0; i < 10; i++)
{
sum = sum + (25648 * i);
if (i % 2 == 0)
{
statsRecorder.NewMeasureMap().Put(VIDEO_SIZE, 25648 * i).Record(context1);
}
else
{
statsRecorder.NewMeasureMap().Put(VIDEO_SIZE, 25648 * i).Record(context2);
}
}
IViewData viewDataByFrontend = viewManager.GetView(VIDEO_SIZE_BY_FRONTEND_VIEW_NAME);
var viewDataAggMap = viewDataByFrontend.AggregationMap.ToList();
output.WriteLine(viewDataByFrontend.ToString());
IViewData viewDataAll = viewManager.GetView(VIDEO_SIZE_ALL_VIEW_NAME);
var viewDataAggMapAll = viewDataAll.AggregationMap.ToList();
output.WriteLine(viewDataAll.ToString());
IViewData viewData1 = viewManager.GetView(VIDEO_SIZE_TOTAL_VIEW_NAME);
var viewData1AggMap = viewData1.AggregationMap.ToList();
output.WriteLine(viewData1.ToString());
IViewData viewData2 = viewManager.GetView(VIDEOS_PROCESSED_VIEW_NAME);
var viewData2AggMap = viewData2.AggregationMap.ToList();
output.WriteLine(viewData2.ToString());
output.WriteLine(sum.ToString());
}
public void GetAvailableTags_ReturnsExpected()
{
var opts = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var ep = new MetricsEndpoint(opts, stats);
SetupTestView(stats, Sum.Create(), null, "test.test1");
var viewData = stats.ViewManager.GetView(ViewName.Create("test.test1"));
var dict = new Dictionary <TagValues, IAggregationData>()
{
{
TagValues.Create(new List <ITagValue>()
{
TagValue.Create("v1"), TagValue.Create("v1"), TagValue.Create("v1")
}),
SumDataDouble.Create(1)
},
{
TagValues.Create(new List <ITagValue>()
{
TagValue.Create("v2"), TagValue.Create("v2"), TagValue.Create("v2")
}),
SumDataDouble.Create(1)
}
};
var result = ep.GetAvailableTags(viewData.View.Columns, dict);
Assert.NotNull(result);
Assert.Equal(3, result.Count);
var tag = result[0];
Assert.Equal("a", tag.Tag);
Assert.Contains("v1", tag.Values);
Assert.Contains("v2", tag.Values);
tag = result[1];
Assert.Equal("b", tag.Tag);
Assert.Contains("v1", tag.Values);
Assert.Contains("v2", tag.Values);
tag = result[2];
Assert.Equal("c", tag.Tag);
Assert.Contains("v1", tag.Values);
Assert.Contains("v2", tag.Values);
dict = new Dictionary <TagValues, IAggregationData>();
result = ep.GetAvailableTags(viewData.View.Columns, dict);
Assert.NotNull(result);
Assert.Equal(3, result.Count);
tag = result[0];
Assert.Equal("a", tag.Tag);
Assert.Empty(tag.Values);
tag = result[1];
Assert.Equal("b", tag.Tag);
Assert.Empty(tag.Values);
tag = result[2];
Assert.Equal("c", tag.Tag);
Assert.Empty(tag.Values);
}
public void TestViewNameEquals()
{
Assert.Equal(ViewName.Create("view-1"), ViewName.Create("view-1"));
Assert.NotEqual(ViewName.Create("view-1"), ViewName.Create("view-2"));
}
public void GetMetricMeasurements_ReturnsExpected()
{
var opts = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var tagsComponent = new TagsComponent();
var tagger = tagsComponent.Tagger;
var ep = new MetricsEndpoint(opts, stats);
var testMeasure = MeasureDouble.Create("test.total", "test", MeasureUnit.Bytes);
SetupTestView(stats, Sum.Create(), testMeasure, "test.test1");
var context1 = tagger
.EmptyBuilder
.Put(TagKey.Create("a"), TagValue.Create("v1"))
.Put(TagKey.Create("b"), TagValue.Create("v1"))
.Put(TagKey.Create("c"), TagValue.Create("v1"))
.Build();
var context2 = tagger
.EmptyBuilder
.Put(TagKey.Create("a"), TagValue.Create("v1"))
.Build();
var context3 = tagger
.EmptyBuilder
.Put(TagKey.Create("b"), TagValue.Create("v1"))
.Build();
var context4 = tagger
.EmptyBuilder
.Put(TagKey.Create("c"), TagValue.Create("v1"))
.Build();
long allKeyssum = 0;
for (var i = 0; i < 10; i++)
{
allKeyssum += i;
stats.StatsRecorder.NewMeasureMap().Put(testMeasure, i).Record(context1);
}
long asum = 0;
for (var i = 0; i < 10; i++)
{
asum += i;
stats.StatsRecorder.NewMeasureMap().Put(testMeasure, i).Record(context2);
}
long bsum = 0;
for (var i = 0; i < 10; i++)
{
bsum += i;
stats.StatsRecorder.NewMeasureMap().Put(testMeasure, i).Record(context3);
}
long csum = 0;
for (var i = 0; i < 10; i++)
{
csum += i;
stats.StatsRecorder.NewMeasureMap().Put(testMeasure, i).Record(context4);
}
var alltags = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("a", "v1"),
new KeyValuePair <string, string>("b", "v1"),
new KeyValuePair <string, string>("c", "v1")
};
var viewData = stats.ViewManager.GetView(ViewName.Create("test.test1"));
var result = ep.GetMetricMeasurements(viewData, alltags);
Assert.NotNull(result);
Assert.Single(result);
var sample = result[0];
Assert.Equal(allKeyssum, sample.Value);
Assert.Equal(MetricStatistic.TOTAL, sample.Statistic);
var atags = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("a", "v1"),
};
result = ep.GetMetricMeasurements(viewData, atags);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(allKeyssum + asum, sample.Value);
Assert.Equal(MetricStatistic.TOTAL, sample.Statistic);
var btags = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("b", "v1"),
};
result = ep.GetMetricMeasurements(viewData, btags);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(allKeyssum + bsum, sample.Value);
Assert.Equal(MetricStatistic.TOTAL, sample.Statistic);
var ctags = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("c", "v1"),
};
result = ep.GetMetricMeasurements(viewData, ctags);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(allKeyssum + csum, sample.Value);
Assert.Equal(MetricStatistic.TOTAL, sample.Statistic);
var abtags = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("a", "v1"),
new KeyValuePair <string, string>("b", "v1"),
};
result = ep.GetMetricMeasurements(viewData, abtags);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(allKeyssum, sample.Value);
Assert.Equal(MetricStatistic.TOTAL, sample.Statistic);
var actags = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("a", "v1"),
new KeyValuePair <string, string>("c", "v1"),
};
result = ep.GetMetricMeasurements(viewData, actags);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(allKeyssum, sample.Value);
Assert.Equal(MetricStatistic.TOTAL, sample.Statistic);
var bctags = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("b", "v1"),
new KeyValuePair <string, string>("c", "v1"),
};
result = ep.GetMetricMeasurements(viewData, bctags);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(allKeyssum, sample.Value);
Assert.Equal(MetricStatistic.TOTAL, sample.Statistic);
}
public void GetMetricSamples_ReturnsExpected()
{
var opts = new MetricsEndpointOptions();
var stats = new OpenCensusStats();
var ep = new MetricsEndpoint(opts, stats);
SetupTestView(stats, Sum.Create(), null, "test.test1");
var viewData = stats.ViewManager.GetView(ViewName.Create("test.test1"));
IAggregationData aggData = SumDataDouble.Create(100);
Assert.NotNull(viewData);
var result = ep.GetMetricSamples(aggData, viewData);
Assert.NotNull(result);
Assert.Single(result);
var sample = result[0];
Assert.Equal(100, sample.Value);
Assert.Equal(MetricStatistic.TOTALTIME, sample.Statistic);
SetupTestView(stats, Sum.Create(), null, "test.test2");
viewData = stats.ViewManager.GetView(ViewName.Create("test.test2"));
aggData = SumDataLong.Create(100);
Assert.NotNull(viewData);
result = ep.GetMetricSamples(aggData, viewData);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(100, sample.Value);
Assert.Equal(MetricStatistic.TOTALTIME, sample.Statistic);
SetupTestView(stats, Count.Create(), null, "test.test3");
viewData = stats.ViewManager.GetView(ViewName.Create("test.test3"));
aggData = CountData.Create(100);
Assert.NotNull(viewData);
result = ep.GetMetricSamples(aggData, viewData);
Assert.NotNull(result);
Assert.Single(result);
sample = result[0];
Assert.Equal(100, sample.Value);
Assert.Equal(MetricStatistic.COUNT, sample.Statistic);
SetupTestView(stats, Mean.Create(), null, "test.test4");
viewData = stats.ViewManager.GetView(ViewName.Create("test.test4"));
aggData = MeanData.Create(100, 50, 1, 500);
Assert.NotNull(viewData);
result = ep.GetMetricSamples(aggData, viewData);
Assert.NotNull(result);
Assert.Equal(2, result.Count);
sample = result[0];
Assert.Equal(50, sample.Value);
Assert.Equal(MetricStatistic.COUNT, sample.Statistic);
sample = result[1];
Assert.Equal(100 * 50, sample.Value);
Assert.Equal(MetricStatistic.TOTALTIME, sample.Statistic);
SetupTestView(stats, Distribution.Create(BucketBoundaries.Create(new List <double>()
{
0.0, 10.0, 20.0
})), null, "test.test5");
viewData = stats.ViewManager.GetView(ViewName.Create("test.test5"));
aggData = DistributionData.Create(100, 50, 5, 200, 5, new List <long>()
{
10, 20, 20
});
Assert.NotNull(viewData);
result = ep.GetMetricSamples(aggData, viewData);
Assert.NotNull(result);
Assert.Equal(3, result.Count);
sample = result[0];
Assert.Equal(50, sample.Value);
Assert.Equal(MetricStatistic.COUNT, sample.Statistic);
sample = result[1];
Assert.Equal(200, sample.Value);
Assert.Equal(MetricStatistic.MAX, sample.Statistic);
sample = result[2];
Assert.Equal(100 * 50, sample.Value);
Assert.Equal(MetricStatistic.TOTALTIME, sample.Statistic);
}
public void Main2()
{
var statsComponent = new StatsComponent();
var viewManager = statsComponent.ViewManager;
var statsRecorder = statsComponent.StatsRecorder;
var tagsComponent = new TagsComponent();
var tagger = tagsComponent.Tagger;
ITagKey FRONTEND_KEY = TagKey.Create("my.org/keys/frontend");
ITagKey FRONTEND_OS_KEY = TagKey.Create("my.org/keys/frontend/os");
ITagKey FRONTEND_OS_VERSION_KEY = TagKey.Create("my.org/keys/frontend/os/version");
IMeasureLong VIDEO_SIZE = MeasureLong.Create("my.org/measure/video_size", "size of processed videos", "MBy");
IViewName VIDEO_SIZE_VIEW_NAME = ViewName.Create("my.org/views/video_size_byfrontend");
IView VIDEO_SIZE_VIEW = View.Create(
VIDEO_SIZE_VIEW_NAME,
"processed video size over time",
VIDEO_SIZE,
Distribution.Create(BucketBoundaries.Create(new List <double>()
{
0.0, 256.0, 65536.0
})),
new List <ITagKey>()
{
FRONTEND_KEY, FRONTEND_OS_KEY, FRONTEND_OS_VERSION_KEY
});
viewManager.RegisterView(VIDEO_SIZE_VIEW);
ITagContext context1 = tagger
.EmptyBuilder
.Put(FRONTEND_KEY, TagValue.Create("front1"))
.Put(FRONTEND_OS_KEY, TagValue.Create("windows"))
.Build();
ITagContext context2 = tagger
.EmptyBuilder
.Put(FRONTEND_KEY, TagValue.Create("front2"))
.Put(FRONTEND_OS_VERSION_KEY, TagValue.Create("1.1.1"))
.Build();
long sum = 0;
for (int i = 0; i < 10; i++)
{
sum = sum + (25648 * i);
if (i % 2 == 0)
{
statsRecorder.NewMeasureMap().Put(VIDEO_SIZE, 25648 * i).Record(context1);
}
else
{
statsRecorder.NewMeasureMap().Put(VIDEO_SIZE, 25648 * i).Record(context2);
}
}
IViewData videoSizeView = viewManager.GetView(VIDEO_SIZE_VIEW_NAME);
var viewDataAggMap = videoSizeView.AggregationMap.ToList();
var view = viewManager.AllExportedViews.ToList()[0];
for (int i = 0; i < view.Columns.Count; i++)
{
output.WriteLine(view.Columns[i] + "=" + GetTagValues(i, viewDataAggMap));
}
var keys = new List <ITagValue>()
{
TagValue.Create("1.1.1")
};
var results = videoSizeView.AggregationMap.Where((kvp) =>
{
foreach (var key in keys)
{
if (!kvp.Key.Values.Contains(key))
{
return(false);
}
}
return(true);
});
output.WriteLine(videoSizeView.ToString());
output.WriteLine(sum.ToString());
}
