Example #1
0
        public void DoNotAcceptOtherValues([Values("help.json", "stdwarn", "release.md")] string output)
        {
            var consoleMock = new Mock <IConsoleWriter>();
            var exporter    = new ConsoleExporter(consoleMock.Object);

            exporter.CanExportToFile(output).ShouldBeFalse();
        }
Example #2
0
        internal static object Run(ConsoleOptions options)
        {
            // map test project settings to ConsoleExporterSetting
            var exporterOptions = new ConsoleExporterOptions
            {
                Pretty = options.Pretty
            };

            // create exporter
            var exporter = new ConsoleExporter(exporterOptions);

            // Create tracer
            using var tracerFactory = TracerFactory.Create(builder => {
                builder.AddProcessorPipeline(p => p.SetExporter(exporter));
            });
            var tracer = tracerFactory.GetTracer("console-test");

            using (tracer.StartActiveSpan("parent", out var parent))
            {
                tracer.CurrentSpan.SetAttribute("key", 123);
                tracer.CurrentSpan.AddEvent("test-event");

                using (tracer.StartActiveSpan("child", out var child))
                {
                    child.SetAttribute("key", "value");
                }
            }

            return(null);
        }
Example #3
0
        public void AcceptsStandardOutputAndStandardError([Values("stdout", "stderr")] string output)
        {
            var consoleMock = new Mock <IConsoleWriter>();
            var exporter    = new ConsoleExporter(consoleMock.Object);

            exporter.CanExportToFile(output).ShouldBeTrue();
        }
Example #4
0
        // ReSharper disable once ArrangeTypeMemberModifiers
        // ReSharper disable once UnusedParameter.Local
        static void Main(string[] args)
        {
            IImporter importer = new SampleDataImporter();
            var       courses  = importer.Import().ToArray();
            IExporter exporter = new ICalExporter(courses);

            exporter.Export();
            exporter = new ConsoleExporter(courses);
            exporter.Export();
        }
Example #5
0
        public void GetsStandardErrorFromConsole()
        {
            var consoleMock = new Mock <IConsoleWriter>();

            consoleMock.SetupGet(c => c.StandardError).Returns(TextWriter.Null);
            var exporter = new ConsoleExporter(consoleMock.Object);

            exporter.ExportParsedData(new ParsedData(VersionData.Parse("1.0.0"), new ReleaseNotesData()), "stderr", false);

            consoleMock.VerifyGet(c => c.StandardError, Times.Once);
        }
Example #6
0
        public void ThrowsNotSupportedExceptionOnInvalidValues([Values("help.json", "stdwarn", "release.md")] string output)
        {
            var consoleMock = new Mock <IConsoleWriter>();

            consoleMock.SetupGet(c => c.StandardError).Returns(TextWriter.Null);
            consoleMock.SetupGet(c => c.StandardOut).Returns(TextWriter.Null);
            var exporter = new ConsoleExporter(consoleMock.Object);

            Should.Throw <NotSupportedException>(() =>
                                                 exporter.ExportParsedData(new ParsedData(VersionData.Parse("1.0.0"), new ReleaseNotesData()), output, false));

            consoleMock.VerifyGet(c => c.StandardOut, Times.Never);
            consoleMock.VerifyGet(c => c.StandardError, Times.Never);
        }
Example #7
0
        /// <summary>
        /// Registers a ConsoleActivity exporter to a processing pipeline.
        /// </summary>
        /// <param name="builder"><see cref="OpenTelemetryBuilder"/> builder to use.</param>
        /// <param name="configure">Exporter configuration options.</param>
        /// <param name="processorConfigure">Activity processor configuration.</param>
        /// <returns>The instance of <see cref="OpenTelemetryBuilder"/> to chain the calls.</returns>
        public static OpenTelemetryBuilder UseConsoleExporter(this OpenTelemetryBuilder builder, Action <ConsoleExporterOptions> configure = null, Action <ActivityProcessorPipelineBuilder> processorConfigure = null)
        {
            if (builder == null)
            {
                throw new ArgumentNullException(nameof(builder));
            }

            return(builder.AddProcessorPipeline(pipeline =>
            {
                var exporterOptions = new ConsoleExporterOptions();
                configure?.Invoke(exporterOptions);

                var consoleExporter = new ConsoleExporter(exporterOptions);
                processorConfigure?.Invoke(pipeline);
                pipeline.SetExporter(consoleExporter);
            }));
        }