Java Code Examples for io.perfmark.PerfMark#startTask()

@Override
public void onNext(O outMesg) {
    boolean stopped = false;
    PerfMark.startTask(filter.filterName(), "onNextAsync");
    try {
        PerfMark.linkIn(onNextLinkOut.get());
        addPerfMarkTags(inMesg);
        recordFilterCompletion(SUCCESS, filter, startTime, inMesg, snapshot);
        if (outMesg == null) {
            outMesg = filter.getDefaultOutput(inMesg);
        }
        stopped = true;
        PerfMark.stopTask(filter.filterName(), "onNextAsync");
        resumeInBindingContext(outMesg, filter.filterName());
    }
    catch (Exception e) {
        decrementConcurrency();
        handleException(inMesg, filter.filterName(), e);
    } finally {
        if (!stopped) {
            PerfMark.stopTask(filter.filterName(), "onNextAsync");
        }
    }
}
 

protected final void invokeNextStage(final O zuulMesg, final HttpContent chunk) {
    if (nextStage != null) {
        PerfMark.startTask(getClass().getName(), "invokeNextStageChunk");
        try {
            addPerfMarkTags(zuulMesg);
            nextStage.filter(zuulMesg, chunk);
        } finally {
            PerfMark.stopTask(getClass().getName(), "invokeNextStageChunk");
        }
    } else {
        //Next stage is Netty channel handler
        PerfMark.startTask(getClass().getName(), "fireChannelReadChunk");
        try {
            addPerfMarkTags(zuulMesg);
            getChannelHandlerContext(zuulMesg).fireChannelRead(chunk);
        } finally {
            PerfMark.stopTask(getClass().getName(), "fireChannelReadChunk");
        }
    }
}
 

@Override
protected void onStreamError(ChannelHandlerContext ctx, boolean outbound, Throwable cause,
    StreamException http2Ex) {
  logger.log(Level.WARNING, "Stream Error", cause);
  NettyServerStream.TransportState serverStream = serverStream(
      connection().stream(Http2Exception.streamId(http2Ex)));
  Tag tag = serverStream != null ? serverStream.tag() : PerfMark.createTag();
  PerfMark.startTask("NettyServerHandler.onStreamError", tag);
  try {
    if (serverStream != null) {
      serverStream.transportReportStatus(Utils.statusFromThrowable(cause));
    }
    // TODO(ejona): Abort the stream by sending headers to help the client with debugging.
    // Delegate to the base class to send a RST_STREAM.
    super.onStreamError(ctx, outbound, cause, http2Ex);
  } finally {
    PerfMark.stopTask("NettyServerHandler.onStreamError", tag);
  }
}
 

@Override
public void closed(Status status) {
  PerfMark.startTask("ServerStreamListener.closed", call.tag);
  try {
    closedInternal(status);
  } finally {
    PerfMark.stopTask("ServerStreamListener.closed", call.tag);
  }
}
 

@Override
protected void resume(final HttpResponseMessage zuulMesg) {
    PerfMark.startTask(getClass().getSimpleName(), "resume");
    try {
        if (zuulMesg.getContext().isCancelled()) {
            return;
        }
        invokeNextStage(zuulMesg);
    } finally {
        PerfMark.stopTask(getClass().getSimpleName(), "resume");
    }
}
 

@Override
public void onError(Throwable ex) {
    PerfMark.startTask(filter.filterName(), "onErrorAsync");
    try {
        PerfMark.linkIn(onErrorLinkOut.get());
        decrementConcurrency();
        recordFilterCompletion(FAILED, filter, startTime, inMesg, snapshot);
        final O outMesg = handleFilterException(inMesg, filter, ex);
        resumeInBindingContext(outMesg, filter.filterName());
    }
    catch (Exception e) {
        handleException(inMesg, filter.filterName(), e);
    } finally {
      PerfMark.stopTask(filter.filterName(), "onErrorAsync");            }
}
 

@Override
public void cancel(Status status) {
  PerfMark.startTask("NettyClientStream$Sink.cancel");
  try {
    writeQueue.enqueue(new CancelClientStreamCommand(transportState(), status), true);
  } finally {
    PerfMark.stopTask("NettyClientStream$Sink.cancel");
  }
}
 

@Override
public void writeHeaders(Metadata headers, byte[] requestPayload) {
  PerfMark.startTask("NettyClientStream$Sink.writeHeaders");
  try {
    writeHeadersInternal(headers, requestPayload);
  } finally {
    PerfMark.stopTask("NettyClientStream$Sink.writeHeaders");
  }
}
 

@Override
public void close(Status status, Metadata trailers) {
  PerfMark.startTask("ServerCall.close", tag);
  try {
    closeInternal(status, trailers);
  } finally {
    PerfMark.stopTask("ServerCall.close", tag);
  }
}
 

private void cancelStream(ChannelHandlerContext ctx, CancelServerStreamCommand cmd,
    ChannelPromise promise) {
  PerfMark.startTask("NettyServerHandler.cancelStream", cmd.stream().tag());
  PerfMark.linkIn(cmd.getLink());
  try {
    // Notify the listener if we haven't already.
    cmd.stream().transportReportStatus(cmd.reason());
    // Terminate the stream.
    encoder().writeRstStream(ctx, cmd.stream().id(), Http2Error.CANCEL.code(), promise);
  } finally {
    PerfMark.stopTask("NettyServerHandler.cancelStream", cmd.stream().tag());
  }
}
 

@Override
public void write(Buffer source, long byteCount) throws IOException {
  checkNotNull(source, "source");
  if (closed) {
    throw new IOException("closed");
  }
  PerfMark.startTask("AsyncSink.write");
  try {
    synchronized (lock) {
      buffer.write(source, byteCount);
      if (writeEnqueued || flushEnqueued || buffer.completeSegmentByteCount() <= 0) {
        return;
      }
      writeEnqueued = true;
    }
    serializingExecutor.execute(new WriteRunnable() {
      final Link link = PerfMark.linkOut();
      @Override
      public void doRun() throws IOException {
        PerfMark.startTask("WriteRunnable.runWrite");
        PerfMark.linkIn(link);
        Buffer buf = new Buffer();
        try {
          synchronized (lock) {
            buf.write(buffer, buffer.completeSegmentByteCount());
            writeEnqueued = false;
          }
          sink.write(buf, buf.size());
        } finally {
          PerfMark.stopTask("WriteRunnable.runWrite");
        }
      }
    });
  } finally {
    PerfMark.stopTask("AsyncSink.write");
  }
}
 

@Override
public void sendHeaders(Metadata headers) {
  PerfMark.startTask("ServerCall.sendHeaders", tag);
  try {
    sendHeadersInternal(headers);
  } finally {
    PerfMark.stopTask("ServerCall.sendHeaders", tag);
  }
}
 

public static <T> T recordTaskResult(String taskName, Tag tag, Supplier<T> cmd) {
  PerfMark.startTask(taskName, tag);
  try {
    return cmd.get();
  } finally {
    PerfMark.stopTask(taskName, tag);
  }
}
 

@Override
public void start(Listener<RespT> observer, Metadata headers) {
  PerfMark.startTask("ClientCall.start", tag);
  try {
    startInternal(observer, headers);
  } finally {
    PerfMark.stopTask("ClientCall.start", tag);
  }
}
 

private Action0 onCompletedStarted(Link onCompletedLinkIn) {
    return () -> {
        PerfMark.startTask(filter.filterName(), "onCompleted");
        try {
            PerfMark.linkIn(onCompletedLinkIn);
            onCompletedLinkOut.compareAndSet(null, PerfMark.linkOut());
        } finally {
            PerfMark.stopTask(filter.filterName(), "onCompleted");                }
    };
}
 

@Override
public void request(int numMessages) {
  PerfMark.startTask("ClientCall.request", tag);
  try {
    checkState(stream != null, "Not started");
    checkArgument(numMessages >= 0, "Number requested must be non-negative");
    stream.request(numMessages);
  } finally {
    PerfMark.stopTask("ClientCall.request", tag);
  }
}
 

@Override
public void headersRead(final Metadata headers) {
  PerfMark.startTask("ClientStreamListener.headersRead", tag);
  final Link link = PerfMark.linkOut();

  final class HeadersRead extends ContextRunnable {
    HeadersRead() {
      super(context);
    }

    @Override
    public void runInContext() {
      PerfMark.startTask("ClientCall$Listener.headersRead", tag);
      PerfMark.linkIn(link);
      try {
        runInternal();
      } finally {
        PerfMark.stopTask("ClientCall$Listener.headersRead", tag);
      }
    }

    private void runInternal() {
      if (closed) {
        return;
      }
      try {
        observer.onHeaders(headers);
      } catch (Throwable t) {
        Status status =
            Status.CANCELLED.withCause(t).withDescription("Failed to read headers");
        stream.cancel(status);
        close(status, new Metadata());
      }
    }
  }

  try {
    callExecutor.execute(new HeadersRead());
  } finally {
    PerfMark.stopTask("ClientStreamListener.headersRead", tag);
  }
}
 

@MustBeClosed
public static TaskRecorder recordTask(String taskName) {
  PerfMark.startTask(taskName);
  return () -> PerfMark.stopTask(taskName);
}
 

@Override
public void onReady() {
  if (method.getType().clientSendsOneMessage()) {
    return;
  }

  PerfMark.startTask("ClientStreamListener.onReady", tag);
  final Link link = PerfMark.linkOut();

  final class StreamOnReady extends ContextRunnable {
    StreamOnReady() {
      super(context);
    }

    @Override
    public void runInContext() {
      PerfMark.startTask("ClientCall$Listener.onReady", tag);
      PerfMark.linkIn(link);
      try {
        runInternal();
      } finally {
        PerfMark.stopTask("ClientCall$Listener.onReady", tag);
      }
    }

    private void runInternal() {
      try {
        observer.onReady();
      } catch (Throwable t) {
        Status status =
            Status.CANCELLED.withCause(t).withDescription("Failed to call onReady.");
        stream.cancel(status);
        close(status, new Metadata());
      }
    }
  }

  try {
    callExecutor.execute(new StreamOnReady());
  } finally {
    PerfMark.stopTask("ClientStreamListener.onReady", tag);
  }
}
 

/**
 * Process the queue of commands and dispatch them to the stream. This method is only
 * called in the event loop
 */
private void flush() {
  PerfMark.startTask("WriteQueue.periodicFlush");
  try {
    QueuedCommand cmd;
    int i = 0;
    boolean flushedOnce = false;
    while ((cmd = queue.poll()) != null) {
      cmd.run(channel);
      if (++i == DEQUE_CHUNK_SIZE) {
        i = 0;
        // Flush each chunk so we are releasing buffers periodically. In theory this loop
        // might never end as new events are continuously added to the queue, if we never
        // flushed in that case we would be guaranteed to OOM.
        PerfMark.startTask("WriteQueue.flush0");
        try {
          channel.flush();
        } finally {
          PerfMark.stopTask("WriteQueue.flush0");
        }
        flushedOnce = true;
      }
    }
    // Must flush at least once, even if there were no writes.
    if (i != 0 || !flushedOnce) {
      PerfMark.startTask("WriteQueue.flush1");
      try {
        channel.flush();
      } finally {
        PerfMark.stopTask("WriteQueue.flush1");
      }
    }
  } finally {
    PerfMark.stopTask("WriteQueue.periodicFlush");
    // Mark the write as done, if the queue is non-empty after marking trigger a new write.
    scheduled.set(false);
    if (!queue.isEmpty()) {
      scheduleFlush();
    }
  }
}