From b196c6498d22e47bb9d0da0153068ec54eac7956 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 28 Apr 2024 11:44:33 +0200 Subject: Adding upstream version 1.6.0. Signed-off-by: Daniel Baumann --- mocktracer/src/tracer.cpp | 109 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 mocktracer/src/tracer.cpp (limited to 'mocktracer/src/tracer.cpp') diff --git a/mocktracer/src/tracer.cpp b/mocktracer/src/tracer.cpp new file mode 100644 index 0000000..e5f9127 --- /dev/null +++ b/mocktracer/src/tracer.cpp @@ -0,0 +1,109 @@ +#include +#include +#include + +#include "mock_span.h" +#include "mock_span_context.h" +#include "propagation.h" + +#include +#include +#include +#include +#include + +namespace opentracing { +BEGIN_OPENTRACING_ABI_NAMESPACE +namespace mocktracer { + +template +static expected InjectImpl(const PropagationOptions& propagation_options, + const opentracing::SpanContext& span_context, + Carrier& writer) { + if (propagation_options.inject_error_code.value() != 0) { + return opentracing::make_unexpected(propagation_options.inject_error_code); + } + auto mock_span_context = dynamic_cast(&span_context); + if (mock_span_context == nullptr) { + return opentracing::make_unexpected( + opentracing::invalid_span_context_error); + } + return mock_span_context->Inject(propagation_options, writer); +} + +template +opentracing::expected> ExtractImpl( + const PropagationOptions& propagation_options, Carrier& reader) { + if (propagation_options.extract_error_code.value() != 0) { + return opentracing::make_unexpected(propagation_options.extract_error_code); + } + MockSpanContext* mock_span_context; + try { + mock_span_context = new MockSpanContext{}; + } catch (const std::bad_alloc&) { + return opentracing::make_unexpected( + make_error_code(std::errc::not_enough_memory)); + } + std::unique_ptr span_context(mock_span_context); + auto result = mock_span_context->Extract(propagation_options, reader); + if (!result) { + return opentracing::make_unexpected(result.error()); + } + if (!*result) { + span_context.reset(); + } + return std::move(span_context); +} + +MockTracer::MockTracer(MockTracerOptions&& options) + : recorder_{std::move(options.recorder)}, + propagation_options_{std::move(options.propagation_options)} {} + +std::unique_ptr MockTracer::StartSpanWithOptions( + string_view operation_name, const StartSpanOptions& options) const + noexcept try { + return std::unique_ptr{new MockSpan{shared_from_this(), recorder_.get(), + operation_name, options}}; +} catch (const std::exception& e) { + fprintf(stderr, "Failed to start span: %s\n", e.what()); + return nullptr; +} + +void MockTracer::Close() noexcept { + if (recorder_ != nullptr) { + recorder_->Close(); + } +} + +expected MockTracer::Inject(const SpanContext& sc, + std::ostream& writer) const { + return InjectImpl(propagation_options_, sc, writer); +} + +expected MockTracer::Inject(const SpanContext& sc, + const TextMapWriter& writer) const { + return InjectImpl(propagation_options_, sc, writer); +} + +expected MockTracer::Inject(const SpanContext& sc, + const HTTPHeadersWriter& writer) const { + return InjectImpl(propagation_options_, sc, writer); +} + +expected> MockTracer::Extract( + std::istream& reader) const { + return ExtractImpl(propagation_options_, reader); +} + +expected> MockTracer::Extract( + const TextMapReader& reader) const { + return ExtractImpl(propagation_options_, reader); +} + +expected> MockTracer::Extract( + const HTTPHeadersReader& reader) const { + return ExtractImpl(propagation_options_, reader); +} +} // namespace mocktracer +END_OPENTRACING_ABI_NAMESPACE +} // namespace opentracing -- cgit v1.2.3