code: def start_span(self,
                     operation_name=None,
                     child_of=None,
                     references=None,
                     tags=None,
                     start_time=None,
                     ignore_active_span=False):
          
          return self._noop_span
docs: Starts and returns a new :class:`Span` representing a unit of work.
  
  
          Starting a root :class:`Span` (a :class:`Span` with no causal
          references)::
  
              tracer.start_span('...')
  
  
          Starting a child :class:`Span` (see also :meth:`start_child_span()`)::
  
              tracer.start_span(
                  '...',
                  child_of=parent_span)
  
  
          Starting a child :class:`Span` in a more verbose way::
  
              tracer.start_span(
                  '...',
                  references=[opentracing.child_of(parent_span)])
  
  
          :param operation_name: name of the operation represented by the new
              :class:`Span` from the perspective of the current service.
          :type operation_name: str
  
          :param child_of: (optional) a :class:`Span` or :class:`SpanContext`
              representing the parent in a REFERENCE_CHILD_OF reference.  If
              specified, the `references` parameter must be omitted.
          :type child_of: Span or SpanContext
  
          :param references: (optional) references that identify one or more
              parent :class:`SpanContext`\ s. (See the Reference documentation
              for detail).
          :type references: :obj:`list` of :class:`Reference`
  
          :param tags: an optional dictionary of :class:`Span` tags. The caller
              gives up ownership of that dictionary, because the :class:`Tracer`
              may use it as-is to avoid extra data copying.
          :type tags: dict
  
          :param start_time: an explicit Span start time as a unix timestamp per
              :meth:`time.time()`
          :type start_time: float
  
          :param ignore_active_span: an explicit flag that ignores the current
              active :class:`Scope` and creates a root :class:`Span`.
          :type ignore_active_span: bool
  
          :rtype: Span
          :return: an already-started :class:`Span` instance.