Set default-constructed timestamp to current time in StartSpan (#18)

Author: isaachier

src/jaegertracing/Span.cpp

@@ -80,15 +80,19 @@ void Span::SetBaggageItem(opentracing::string_view restrictedKey,
 void Span::FinishWithOptions(
     const opentracing::FinishSpanOptions& finishSpanOptions) noexcept
 {
+    const auto finishTimeSteady =
+        (finishSpanOptions.finish_steady_timestamp ==
+          SteadyClock::time_point())
+         ? SteadyClock::now() : finishSpanOptions.finish_steady_timestamp;
     std::shared_ptr<const Tracer> tracer;
     {
+
         std::lock_guard<std::mutex> lock(_mutex);
         if (isFinished()) {
             // Already finished, so return immediately.
             return;
         }
-        _duration =
-            finishSpanOptions.finish_steady_timestamp - _startTimeSteady;
+        _duration = finishTimeSteady - _startTimeSteady;
         tracer = _tracer;
     }
 

src/jaegertracing/Tracer.cpp

@@ -19,6 +19,35 @@
 #include "jaegertracing/Reference.h"
 
 namespace jaegertracing {
+namespace {
+
+using SystemClock = Tracer::SystemClock;
+using SteadyClock = Tracer::SteadyClock;
+using TimePoints = std::tuple<SystemClock::time_point, SteadyClock::time_point>;
+
+TimePoints determineStartTimes(const opentracing::StartSpanOptions& options)
+{
+    if (options.start_system_timestamp == SystemClock::time_point() &&
+        options.start_steady_timestamp == SteadyClock::time_point()) {
+        return std::make_tuple(SystemClock::now(), SteadyClock::now());
+    }
+    if (options.start_system_timestamp == SystemClock::time_point()) {
+        return std::make_tuple(
+            opentracing::convert_time_point<SystemClock>(
+                options.start_steady_timestamp),
+            options.start_steady_timestamp);
+    }
+    if (options.start_steady_timestamp == SteadyClock::time_point()) {
+        return std::make_tuple(
+            options.start_system_timestamp,
+            opentracing::convert_time_point<SteadyClock>(
+                options.start_system_timestamp));
+    }
+    return std::make_tuple(options.start_system_timestamp,
+                           options.start_steady_timestamp);
+}
+
+}  // anonymous namespace
 
 using StrMap = SpanContext::StrMap;
 
@@ -75,10 +104,14 @@ Tracer::StartSpanWithOptions(string_view operationName,
             ctx = ctx.withBaggage(parent->baggage());
         }
 
+        SystemClock::time_point startTimeSystem;
+        SteadyClock::time_point startTimeSteady;
+        std::tie(startTimeSystem, startTimeSteady) =
+            determineStartTimes(options);
         return startSpanInternal(ctx,
                                  operationName,
-                                 options.start_system_timestamp,
-                                 options.start_steady_timestamp,
+                                 startTimeSystem,
+                                 startTimeSteady,
                                  samplerTags,
                                  options.tags,
                                  newTrace,

src/jaegertracing/TracerTest.cpp

@@ -81,6 +81,14 @@ struct ReaderMock : public BaseReader {
     const StrMap& _keyValuePairs;
 };
 
+template <typename ClockType>
+typename ClockType::duration absTimeDiff(
+    const typename ClockType::time_point& lhs,
+    const typename ClockType::time_point& rhs)
+{
+    return (rhs < lhs) ? (lhs - rhs) : (rhs - lhs);
+}
+
 }  // anonymous namespace
 
 TEST(Tracer, testTracer)
@@ -161,6 +169,46 @@ TEST(Tracer, testTracer)
         tracer->StartSpanWithOptions("test-span-with-debug-parent", options)
             .release()));
 
+    options.references.clear();
+    options.references.emplace_back(
+        opentracing::SpanReferenceType::FollowsFromRef, &parentCtx);
+    options.start_steady_timestamp = Tracer::SteadyClock::now();
+    span.reset(static_cast<Span*>(
+        tracer->StartSpanWithOptions("test-span-with-default-system-timestamp",
+                                     options)
+            .release()));
+    const auto calculatedSystemTime =
+       static_cast<Tracer::SystemClock::time_point>(
+            opentracing::convert_time_point<Tracer::SystemClock>(
+                span->startTimeSteady()));
+    ASSERT_GE(
+        std::chrono::milliseconds(10),
+        absTimeDiff<Tracer::SystemClock>(
+            span->startTimeSystem(), calculatedSystemTime));
+
+    options.start_system_timestamp = Tracer::SystemClock::now();
+    span.reset(static_cast<Span*>(
+        tracer->StartSpanWithOptions("test-span-with-default-steady-timestamp",
+                                     options)
+            .release()));
+    const auto calculatedSteadyTime =
+       static_cast<Tracer::SteadyClock::time_point>(
+            opentracing::convert_time_point<Tracer::SteadyClock>(
+                span->startTimeSystem()));
+    ASSERT_GE(
+        std::chrono::milliseconds(10),
+        absTimeDiff<Tracer::SteadyClock>(
+            span->startTimeSteady(), calculatedSteadyTime));
+
+    options.start_system_timestamp = Tracer::SystemClock::now();
+    options.start_steady_timestamp = Tracer::SteadyClock::now();
+    span.reset(static_cast<Span*>(
+        tracer->StartSpanWithOptions("test-span-with-both-timestamps",
+                                     options)
+            .release()));
+    ASSERT_EQ(options.start_system_timestamp, span->startTimeSystem());
+    ASSERT_EQ(options.start_steady_timestamp, span->startTimeSteady());
+
     span.reset();
 
     opentracing::Tracer::InitGlobal(opentracing::MakeNoopTracer());