public void Test1()
 {
     var collectorEventsProducerFactory = new CollectorEventsProducerFactory(eventHubsConf);
     var collector   = new TestCollector();
     var eventSource = collectorEventsProducerFactory.CreateSource(collector, new TestHealthStore());
     // assert that collector is getting all the events
 }
Ejemplo n.º 2
0
        public void DoTest()
        {
            if (verbose)
            {
                Console.WriteLine("");
                Console.WriteLine("Query: " + queryText);
            }

            SrndQuery lq = Parser.QueryParser.Parse(queryText);

            /* if (verbose) System.out.println("Srnd: " + lq.toString()); */

            Search.Query query = lq.MakeLuceneQueryField(fieldName, qf);
            /* if (verbose) System.out.println("Lucene: " + query.toString()); */

            TestCollector tc = new TestCollector(this);

            using (IndexReader reader = DirectoryReader.Open(dBase.Db))
            {
                IndexSearcher searcher = new IndexSearcher(reader);

                searcher.Search(query, tc);
            }
            tc.CheckNrHits();
        }
Ejemplo n.º 3
0
        public void Should_properly_wrap_a_raw_message()
        {
            var message = new MyMessage();

            var collector = new TestCollector(typeof(MyMessage));

            _contextFactory.Create(message, collector);
        }
Ejemplo n.º 4
0
        public void Should_identify_a_wrapped_message_behind_the_interface()
        {
            var message = new MyMessage();
            var wrapped = new MessageImpl <MyMessage>(message);

            var collector = new TestCollector(typeof(MyMessage));

            _contextFactory.Create(wrapped, collector);
        }
        public async Task AddOpenTelemetry_RegisterCollector_CollectorCreatedAndDisposed()
        {
            var testCollector = new TestCollector();
            var callbackRun   = false;

            var builder = new HostBuilder().ConfigureServices(services =>
            {
                services.AddOpenTelemetry(telemetry =>
                {
                    telemetry.AddCollector(t =>
                    {
                        callbackRun = true;
                        return(testCollector);
                    });
                });
            });

            var host = builder.Build();

            Assert.False(callbackRun);
            Assert.False(testCollector.Disposed);

            await host.StartAsync();

            Assert.True(callbackRun);
            Assert.False(testCollector.Disposed);

            await host.StopAsync();

            Assert.True(callbackRun);
            Assert.False(testCollector.Disposed);

            host.Dispose();

            Assert.True(callbackRun);
            Assert.True(testCollector.Disposed);
        }
        public void AddOpenTelemetry_ServiceProviderArgument_ServicesRegistered()
        {
            var testCollector = new TestCollector();

            var services = new ServiceCollection();

            services.AddSingleton(testCollector);
            services.AddOpenTelemetry((provider, builder) =>
            {
                builder.AddCollector <TestCollector>(tracer => provider.GetRequiredService <TestCollector>());
            });

            var serviceProvider = services.BuildServiceProvider();

            var tracerFactory = serviceProvider.GetRequiredService <TracerFactory>();

            Assert.NotNull(tracerFactory);

            Assert.False(testCollector.Disposed);

            serviceProvider.Dispose();

            Assert.True(testCollector.Disposed);
        }
Ejemplo n.º 7
0
        public void CreateFactory_BuilderWithArgs()
        {
            var exporterCalledCount = 0;

            var testExporter = new TestExporter(spans =>
            {
                exporterCalledCount++;
                Assert.Single(spans);
                Assert.IsType <SpanData>(spans.Single());
            });

            TestCollector collector1    = null;
            TestCollector collector2    = null;
            TestProcessor processor     = null;
            var           tracerFactory = TracerFactory.Create(b => b
                                                               .AddProcessorPipeline(p => p
                                                                                     .SetExporter(testExporter)
                                                                                     .SetExportingProcessor(e =>
            {
                processor = new TestProcessor(e);
                return(processor);
            }))
                                                               .AddCollector(t =>
            {
                collector1 = new TestCollector(t);
                return(collector1);
            })
                                                               .AddCollector(t =>
            {
                collector2 = new TestCollector(t);
                return(collector2);
            }));

            var tracer = tracerFactory.GetTracer("my-app");
            var span   = tracer.StartSpan("foo");

            span.End();

            // default sampler is always sample
            Assert.True(span.IsRecording);
            Assert.Equal(1, exporterCalledCount);
            Assert.Single(((SpanSdk)span).LibraryResource.Attributes);
            Assert.Single(((SpanSdk)span).LibraryResource.Attributes.Where(kvp => kvp.Key == "name" && kvp.Value == "my-app"));

            Assert.NotNull(collector1);
            Assert.NotNull(collector2);
            Assert.NotNull(processor);

            var span1 = collector1.Collect();
            var span2 = collector1.Collect();

            Assert.Equal(3, exporterCalledCount);

            Assert.Equal(2, span1.LibraryResource.Attributes.Count());
            Assert.Equal(2, span2.LibraryResource.Attributes.Count());
            Assert.Single(span1.LibraryResource.Attributes.Where(kvp => kvp.Key == "name" && kvp.Value is string sv && sv == "TestCollector"));
            Assert.Single(span2.LibraryResource.Attributes.Where(kvp => kvp.Key == "name" && kvp.Value is string sv && sv == "TestCollector"));

            Assert.Single(span1.LibraryResource.Attributes.Where(kvp => kvp.Key == "version" && kvp.Value is string sv && sv == "semver:1.0.0.0"));
            Assert.Single(span2.LibraryResource.Attributes.Where(kvp => kvp.Key == "version" && kvp.Value is string sv && sv == "semver:1.0.0.0"));

            tracerFactory.Dispose();
            Assert.True(collector1.IsDisposed);
            Assert.True(collector2.IsDisposed);
            Assert.True(processor.IsDisposed);
        }
Ejemplo n.º 8
0
        public void DoTest()
        {

            if (verbose)
            {
                Console.WriteLine("");
                Console.WriteLine("Query: " + queryText);
            }

            SrndQuery lq = Parser.QueryParser.Parse(queryText);

            /* if (verbose) System.out.println("Srnd: " + lq.toString()); */

            Search.Query query = lq.MakeLuceneQueryField(fieldName, qf);
            /* if (verbose) System.out.println("Lucene: " + query.toString()); */

            TestCollector tc = new TestCollector(this);
            using (IndexReader reader = DirectoryReader.Open(dBase.Db))
            {
                IndexSearcher searcher = new IndexSearcher(reader);

                searcher.Search(query, tc);
            }
            tc.CheckNrHits();
        }
Ejemplo n.º 9
0
		public static void Main ()
		{
			Scheduler sched = Scheduler.Global;

			Scheduler.TaskGroup tg = Scheduler.NewTaskGroup ("foo",
									 new Scheduler.Hook (BeginTaskGroup),
									 new Scheduler.Hook (EndTaskGroup));

			sched.Start ();

			Scheduler.Task task;

			task = new TestTask ();
			task.Tag = "Foo";
			task.AddTaskGroup (tg);
			task.Priority = Scheduler.Priority.Delayed;
			task.TriggerTime = DateTime.Now.AddSeconds (7);
			sched.Add (task);

			task = new TestTask ();
			task.Tag = "Bar";			
			task.AddTaskGroup (tg);
			task.Priority = Scheduler.Priority.Delayed;
			sched.Add (task);

			Scheduler.ITaskCollector collector = null;
			for (int i = 0; i < 20; ++i) {
				if ((i % 10) == 0)
					collector = new TestCollector ();
				task = new TestTask ();
				task.Tag = String.Format ("Baboon {0}", i);
				task.Collector = collector;
				task.Priority = Scheduler.Priority.Delayed;
				sched.Add (task);
			}

			while (true) {
				Thread.Sleep (1000);
			}
		}