internal Tracing()
        {
            IEventQueue eventQueue = new SimpleEventQueue();

            TraceConfig = new Config.TraceConfig();

            SpanExporter = Export.SpanExporter.Create();

            IStartEndHandler startEndHandler =
                new StartEndHandler(
                    SpanExporter,
                    eventQueue);

            tracer = new Tracer(startEndHandler, TraceConfig);
        }
        internal static object Run()
        {
            SimpleEventQueue eventQueue      = new SimpleEventQueue();
            ExportComponent  exportComponent = ExportComponent.CreateWithInProcessStores(eventQueue);

            TelemetryConfiguration.Active.InstrumentationKey = "instrumentation-key";
            var exporter = new ApplicationInsightsExporter(exportComponent, Stats.ViewManager, TelemetryConfiguration.Active);

            exporter.Start();

            var tagContextBuilder = Tagger.CurrentBuilder.Put(FrontendKey, TagValue.Create("mobile-ios9.3.5"));

            var spanBuilder = Tracer
                              .SpanBuilder("incoming request")
                              .SetRecordEvents(true)
                              .SetSampler(Samplers.AlwaysSample);

            Stats.ViewManager.RegisterView(VideoSizeView);

            using (tagContextBuilder.BuildScoped())
            {
                using (Tracer.WithSpan(spanBuilder.StartSpan()))
                {
                    Tracer.CurrentSpan.AddEvent("Start processing video.");
                    Thread.Sleep(TimeSpan.FromMilliseconds(10));
                    StatsRecorder.NewMeasureMap().Put(VideoSize, 25 * MiB).Record();
                    Tracer.CurrentSpan.AddEvent("Finished processing video.");
                }
            }

            Thread.Sleep(TimeSpan.FromMilliseconds(5100));

            var viewData = Stats.ViewManager.GetView(VideoSizeViewName);

            Console.WriteLine(viewData);

            Console.WriteLine("Done... wait for events to arrive to backend!");
            Console.ReadLine();

            exportComponent.SpanExporter.Dispose();

            return(null);
        }
示例#3
0
        static async Task Main(string[] args)
        {
            var queue     = new SimpleEventQueue();
            var simpleLog = new SimpleConsoleLog();

            using (var unitOfWork = new MovienUnitOfWork()) {
                await unitOfWork.Setup();

                var cache = new Cache(unitOfWork.WebPages);

                using (var cachingService = new CachingService(queue, cache))
                    using (var loader = new LoaderService(queue, throttling: TimeSpan.FromSeconds(1), simpleLog, cache)) {
                        var lostFilmLoader       = new LostFilmParserService(queue);
                        var lostFilmSeriesLoader = new LostFilmSeriesesLoader(queue);

                        lostFilmSeriesLoader.Start();
                        Console.ReadLine();
                    }
            }
        }
示例#4
0
        internal Tracing()
        {
            IEventQueue eventQueue = new SimpleEventQueue();

            TraceConfig = new Config.TraceConfig();

            // TODO(bdrutu): Add a config/argument for supportInProcessStores.
            if (eventQueue is SimpleEventQueue)
            {
                ExportComponent = Export.ExportComponent.CreateWithoutInProcessStores(eventQueue);
            }
            else
            {
                ExportComponent = Export.ExportComponent.CreateWithInProcessStores(eventQueue);
            }

            IStartEndHandler startEndHandler =
                new StartEndHandler(
                    ExportComponent.SpanExporter,
                    eventQueue);

            tracer = new Tracer(startEndHandler, TraceConfig);
        }