def test_explicit_start_time(self): """Test `start_time` argument.""" now = time.time() with self.shim.start_active_span("TestSpan4", start_time=now) as scope: result = util.time_seconds_from_ns(scope.span.unwrap().start_time) # Tolerate inaccuracies of less than a microsecond. See Note: # https://open-telemetry.github.io/opentelemetry-python/opentelemetry.shim.opentracing_shim.html # TODO: This seems to work consistently, but we should find out the # biggest possible loss of precision. self.assertAlmostEqual(result, now, places=6)
def test_explicit_end_time(self): """Test `end_time` argument of `finish()` method.""" span = self.shim.start_span("TestSpan5") now = time.time() span.finish(now) end_time = util.time_seconds_from_ns(span.unwrap().end_time) # Tolerate inaccuracies of less than a microsecond. See Note: # https://open-telemetry.github.io/opentelemetry-python/opentelemetry.shim.opentracing_shim.html # TODO: This seems to work consistently, but we should find out the # biggest possible loss of precision. self.assertAlmostEqual(end_time, now, places=6)
def test_time_conversion_precision(self): """Verify time conversion from seconds to nanoseconds and vice versa is accurate enough. """ time_seconds = 1570484241.9501917 time_nanoseconds = util.time_seconds_to_ns(time_seconds) result = util.time_seconds_from_ns(time_nanoseconds) # Tolerate inaccuracies of less than a microsecond. # TODO: Put a link to an explanation in the docs. # TODO: This seems to work consistently, but we should find out the # biggest possible loss of precision. self.assertAlmostEqual(result, time_seconds, places=6)
def test_log_kv(self): """Test the `log_kv()` method on `Span` objects.""" with self.shim.start_span("TestSpan12") as span: span.log_kv({"foo": "bar"}) self.assertEqual(span.unwrap().events[0].attributes["foo"], "bar") # Verify timestamp was generated automatically. self.assertIsNotNone(span.unwrap().events[0].timestamp) # Test explicit timestamp. now = time.time() span.log_kv({"foo": "bar"}, now) result = util.time_seconds_from_ns( span.unwrap().events[1].timestamp) self.assertEqual(span.unwrap().events[1].attributes["foo"], "bar") # Tolerate inaccuracies of less than a microsecond. See Note: # https://open-telemetry.github.io/opentelemetry-python/shim/opentracing_shim/opentracing_shim.html # TODO: This seems to work consistently, but we should find out the # biggest possible loss of precision. self.assertAlmostEqual(result, now, places=6)
def test_time_seconds_from_ns(self): time_nanoseconds = time_ns() result = util.time_seconds_from_ns(time_nanoseconds) self.assertEqual(result, time_nanoseconds / 1e9)