docs: @Override public Call<Void> accept(List<Span> input) {
      if (input.isEmpty()) return Call.create(null);
  
      Set<InsertSpan.Input> spans = new LinkedHashSet<>();
      Set<InsertServiceRemoteService.Input> serviceRemoteServices = new LinkedHashSet<>();
      Set<InsertServiceSpan.Input> serviceSpans = new LinkedHashSet<>();
      Set<InsertTraceByServiceRemoteService.Input> traceByServiceRemoteServices =
        new LinkedHashSet<>();
      Set<InsertTraceByServiceSpan.Input> traceByServiceSpans = new LinkedHashSet<>();
      Set<Map.Entry<String, String>> autocompleteTags = new LinkedHashSet<>();
  
      for (Span s : input) {
        // indexing occurs by timestamp, so derive one if not present.
        long ts_micro = s.timestampAsLong();
        if (ts_micro == 0L) ts_micro = guessTimestamp(s);
  
        // fallback to current time on the ts_uuid for span data, so we know when it was inserted
        UUID ts_uuid =
          new UUID(
            UUIDs.startOf(ts_micro != 0L ? (ts_micro / 1000L) : System.currentTimeMillis())
              .getMostSignificantBits(),
            UUIDs.random().getLeastSignificantBits());
  
        spans.add(insertSpan.newInput(s, ts_uuid));
  
        if (!searchEnabled) continue;
  
        // Empty values allow for api queries with blank service or span name
        String service = s.localServiceName() != null ? s.localServiceName() : "";
        String span =
          null != s.name() ? s.name() : ""; // Empty value allows for api queries without span name
  
        if (null == s.localServiceName()) continue; // don't index further w/o a service name
  
        // service span and remote service indexes is refreshed regardless of timestamp
        String remoteService = s.remoteServiceName();
        if (insertServiceRemoteService != null && remoteService != null) {
          serviceRemoteServices.add(insertServiceRemoteService.newInput(service, remoteService));
        }
        serviceSpans.add(insertServiceSpan.newInput(service, span));
  
        if (ts_micro == 0L) continue; // search is only valid with a timestamp, don't index w/o it!
        int bucket = durationIndexBucket(ts_micro); // duration index is milliseconds not microseconds
        long duration = s.durationAsLong() / 1000L;
        traceByServiceSpans.add(
          insertTraceByServiceSpan.newInput(service, span, bucket, ts_uuid, s.traceId(), duration));
        if (span.isEmpty()) continue;
  
        if (insertServiceRemoteService != null && remoteService != null) {
          traceByServiceRemoteServices.add(
            insertTraceByServiceRemoteService.newInput(service, remoteService, bucket, ts_uuid,
              s.traceId()));
        }
        traceByServiceSpans.add( // Allows lookup without the span name
          insertTraceByServiceSpan.newInput(service, "", bucket, ts_uuid, s.traceId(), duration));
  
        if (insertAutocompleteValue != null) {
          for (Map.Entry<String, String> entry : s.tags().entrySet()) {
            if (autocompleteKeys.contains(entry.getKey())) autocompleteTags.add(entry);
          }
        }
      }
      List<Call<Void>> calls = new ArrayList<>();
      for (InsertSpan.Input span : spans) {
        calls.add(insertSpan.create(span));
      }
      for (InsertServiceSpan.Input serviceSpan : serviceSpans) {
        insertServiceSpan.maybeAdd(serviceSpan, calls);
      }
      for (InsertServiceRemoteService.Input serviceRemoteService : serviceRemoteServices) {
        insertServiceRemoteService.maybeAdd(serviceRemoteService, calls);
      }
      for (InsertTraceByServiceSpan.Input serviceSpan : traceByServiceSpans) {
        calls.add(insertTraceByServiceSpan.create(serviceSpan));
      }
      for (InsertTraceByServiceRemoteService.Input serviceRemoteService : traceByServiceRemoteServices) {
        calls.add(insertTraceByServiceRemoteService.create(serviceRemoteService));
      }
      for (Map.Entry<String, String> autocompleteTag : autocompleteTags) {
        insertAutocompleteValue.maybeAdd(autocompleteTag, calls);
      }
      return calls.isEmpty() ? Call.create(null) : AggregateCall.newVoidCall(calls);
    }