Offer a specific/static no-op `Span` instance.

[carlosalberto]

In Java, we have a DefaultSpan which does nothing by default (it can propagate SpanContext too, but that's more of additional stuff), and can be used as both a no-op object.

Specifically, DefaultSpan.getInvalid() offers a static instance that can also be used when setting parent (through SpanBuilder.serParent()) and also for Tracer.getCurrentSpan() (so the user doesn't have to do a null check).

As Span at this moment already has this no-op functionality, maybe it makes sense to add a class field? This way we could do:

def start_span(..., parent = Span.invalid(), ...):
   if parent is Span.invalid():
     # fetch the actual current Span as parent.

def get_current_span(self):
   ...
   # Return a no-op in case there's no current Span.
   return Span.invalid()

[Oberon00]

Yeah, a designated instance would be nice, if only to improve performance. If we want to enforce that there can be only one instance of plain Span we could even override __init__ to throw if type(self) is Span (one can set __init__ after creating the singleton instance). But instead of a method I'd prefer a module or class-level attribute.

We could even override __new__(cls, *args, **kwargs) to always return the same instance (falling back to Python's default of creating a new instance if cls is not Span), but that is probably too much magic.

[c24t]

👍 for having our own designated default span singleton.

One argument for making this a module-level constant is that it means one less concrete method in the API class (assuming you're saying we'd implement invalid in the API), but either way SGTM.

@Oberon00 you think it's worth locking down instantiation of Span? It does seem like it'd always be a mistake to create more than one plain Span, but it's not clear that it's worth the extra complexity to forbid it.

[Oberon00]

@Oberon00 you think it's worth locking down instantiation of Span?

If you think that it is always a mistake to create a new Span then yes. It's easy after all:

class Span:
    """"..."""

INVALID_SPAN = Span()

def _init_span(self):
  if type(self) is Span: raise RuntimeError("Cannot create a new plain Span")

Span.__init__ = _init_span

Then there is also always the argument that allowing something later is a new feature but banning something later is a breaking change.

[carlosalberto]

It does seem like it'd always be a mistake to create more than one plain Span, but it's not clear that it's worth the extra complexity to forbid it.

At least in Java, a few DefaultSpan objects can be created (indirectly), while users are encouraged to use DefaultSpan.getInvalid(). Once the objects make this assumption is very clear, we should be fine.

[c24t]

Closed by #63.