How to use

trace

method

in

org.slf4j.Logger

public void trace(Object message) {
  if (message instanceof String || this.logger.isTraceEnabled()) {
    this.logger.trace(String.valueOf(message));
  }
}

public Object getState(long txid) {
  final Object state = _curr.get(txid);
  LOG.debug("Getting state. [txid = {}] => [state = {}]", txid, state);
  LOG.trace("Internal state [{}]", this);
  return state;
}

  @Override
  protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
    if (sourceInputLog.isTraceEnabled()) {
      sourceInputLog.trace("Recv network data: {} bytes via input '{}' <{}> from remote address {}",
          msg.readableBytes(), sourceInputName, sourceInputId, ctx.channel().remoteAddress());
    }
  }
}

if (LOG.isTraceEnabled()) {
  LOG.trace("0x{} buf {}",
      Long.toHexString(sessionId),
      ByteBufUtil.hexDump(buf));
  LOG.debug("Received message while throttled");
    LOG.debug("allocating queue");
    queuedBuffer = channel.alloc().buffer(buf.readableBytes());
  if (LOG.isTraceEnabled()) {
    LOG.trace("0x{} queuedBuffer {}",
        Long.toHexString(sessionId),
        ByteBufUtil.hexDump(queuedBuffer));
      if (LOG.isTraceEnabled()) {
        LOG.trace("Before copy {}", buf);
        queuedBuffer = channel.alloc().buffer(buf.readableBytes());
      if (LOG.isTraceEnabled()) {
        LOG.trace("Copy is {}", queuedBuffer);
        LOG.trace("0x{} queuedBuffer {}",
            Long.toHexString(sessionId),
            ByteBufUtil.hexDump(queuedBuffer));

protected SessionValidationScheduler createSessionValidationScheduler() {
  ExecutorServiceSessionValidationScheduler scheduler;
  if (log.isDebugEnabled()) {
    log.debug("No sessionValidationScheduler set.  Attempting to create default instance.");
  }
  scheduler = new ExecutorServiceSessionValidationScheduler(this);
  scheduler.setInterval(getSessionValidationInterval());
  if (log.isTraceEnabled()) {
    log.trace("Created default SessionValidationScheduler instance of type [" + scheduler.getClass().getName() + "].");
  }
  return scheduler;
}

  if (LOG.isTraceEnabled()) {
    LOG.trace("Found position {} beyond {}", recordStream.getCurrentPosition(), dlsn);
    if (LOG.isTraceEnabled()) {
      LOG.trace("Found position {} beyond {}", currTxId, txId);
  recordSetReader = LogRecordSet.of(record);
} else {
  int length = in.readInt();
  if (length < 0) {
  if (LOG.isTraceEnabled()) {
    LOG.trace("Skipped Record with TxId {} DLSN {}",
      currTxId, recordStream.getCurrentPosition());
LOG.debug("Skip encountered end of file Exception", eof);
break;

final List<PeerSetSids> peerSetSids = new ArrayList<>();
for (final Entry<Integer, ByteBuf> entry : attributes.entries()) {
  LOG.trace("Link attribute TLV {}", entry.getKey());
  final int key = entry.getKey();
  final ByteBuf value = entry.getValue();
    break;
  case LINK_PROTECTION_TYPE:
    builder.setLinkProtection(LinkProtectionType.forValue(value.readShort()));
    LOG.debug("Parsed Link Protection Type {}", builder.getLinkProtection());
    break;
  builder.setPeerSetSids(peerSetSids);
LOG.trace("Finished parsing Link Attributes.");
return new LinkAttributesCaseBuilder().setLinkAttributes(builder.build()).build();

protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws IOException {
  if (in.readableBytes() == 0) {
    loggerWire.trace("in.readableBytes() == 0");
    return;
  }
  loggerWire.trace("Decoding frame (" + in.readableBytes() + " bytes)");
  List<FrameCodec.Frame> frames = frameCodec.readFrames(in);
  // Check if a full frame was available.  If not, we'll try later when more bytes come in.
  if (frames == null || frames.isEmpty()) return;
  for (int i = 0; i < frames.size(); i++) {
    FrameCodec.Frame frame = frames.get(i);
    channel.getNodeStatistics().rlpxInMessages.add();
  }
  out.addAll(frames);
}

LOG.trace("Attempting to decode DNS record [{}]", dnsRecord);
try {
  final ByteBuf byteBuf = dnsRawRecord.content();
  ipAddressBytes = new byte[byteBuf.readableBytes()];
  int readerIndex = byteBuf.readerIndex();
  byteBuf.getBytes(readerIndex, ipAddressBytes);
} finally {
LOG.trace("The IP address has [{}] bytes", ipAddressBytes.length);
LOG.trace("The resulting IP address is [{}]", ipAddress.getHostAddress());

@Override
public void read(MysqlClientHandler handler, ByteBuf in) {
  int begin = in.readerIndex();
  int index = in.readerIndex();
  colCount = (int)BufferUtils.readLength(in);
  int readCnt = in.readerIndex() - index;
  int end = in.readerIndex();
  if (_log.isTraceEnabled())
    in.readerIndex(begin);
    in.readBytes(bytes);
    String dump = '\n' + UberUtil.hexDump(bytes);
    _log.trace("Packet Info:\n"
        + this.toString()
        + "\nRowsEventV2Packet packet:\n" 

@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
  throws Exception {
 if (in.readableBytes() < 4) {
  return;
 }
 in.markReaderIndex();
 int msgSize = in.readInt();
 checkSize(msgSize);
 if (in.readableBytes() < msgSize) {
  // Incomplete message in buffer.
  in.resetReaderIndex();
  return;
 }
 try {
  ByteBuffer nioBuffer = maybeDecrypt(in.nioBuffer(in.readerIndex(), msgSize));
  Input kryoIn = new Input(new ByteBufferInputStream(nioBuffer));
  Object msg = kryos.get().readClassAndObject(kryoIn);
  LOG.trace("Decoded message of type {} ({} bytes)",
    msg != null ? msg.getClass().getName() : msg, msgSize);
  out.add(msg);
 } finally {
  in.skipBytes(msgSize);
 }
}

@Override
public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception
  if (in.readableBytes() < 8)
  int compressedFileSize = copy.readInt();
  if (size + 3 + breaks > in.readableBytes())
    logger.trace("Index {} archive {}: Not enough data yet {} > {}", index, file, size + 3 + breaks, in.readableBytes());
    return;
    int bytesToRead = Math.min(bytesInBlock, size - compressedData.writerIndex());
    logger.trace("{}/{}: reading block {}/{}, read so far this block: {}, file status: {}/{}",
      index, file,
      (totalRead % CHUNK_SIZE), CHUNK_SIZE,
  logger.trace("{}/{}: done downloading file, remaining buffer {}",
    index, file,
    in.readableBytes());

private boolean threadShouldExit(long now, long curHardShutdownTimeMs) {
  if (!hasActiveExternalCalls()) {
    log.trace("All work has been completed, and the I/O thread is now exiting.");
    return true;
  }
  if (now >= curHardShutdownTimeMs) {
    log.info("Forcing a hard I/O thread shutdown. Requests in progress will be aborted.");
    return true;
  }
  log.debug("Hard shutdown in {} ms.", curHardShutdownTimeMs - now);
  return false;
}

while(message.isReadable() && !throttled.get()) {
  if (bb != null) {
    if (LOG.isTraceEnabled()) {
      LOG.trace("message readable {} bb len {} {}",
          message.readableBytes(),
          bb.remaining(),
          bb);
      ByteBuffer dat = bb.duplicate();
      dat.flip();
      LOG.trace("0x{} bb {}",
          Long.toHexString(sessionId),
          ByteBufUtil.hexDump(Unpooled.wrappedBuffer(dat)));
    if (LOG.isTraceEnabled()) {
      LOG.trace("after readBytes message readable {} bb len {} {}",
      ByteBuffer dat = bb.duplicate();
      dat.flip();
      LOG.trace("after readbytes 0x{} bb {}",
          Long.toHexString(sessionId),
          ByteBufUtil.hexDump(Unpooled.wrappedBuffer(dat)));
    if (LOG.isTraceEnabled()) {
      LOG.trace("message readable {} bblenrem {}",
      ByteBuffer dat = bbLen.duplicate();
      dat.flip();
      LOG.trace("0x{} bbLen {}",
          Long.toHexString(sessionId),

public void trace(Object message, Throwable exception) {
  if (message instanceof String || this.logger.isTraceEnabled()) {
    this.logger.trace(String.valueOf(message), exception);
  }
}

return httpContentFlowable.map((Function<HttpContent, io.micronaut.http.HttpResponse<ByteBuffer<?>>>) message -> {
  ByteBuf byteBuf = message.content();
  if (log.isTraceEnabled()) {
    log.trace("HTTP Client Streaming Response Received Chunk (length: {})", byteBuf.readableBytes());
    traceBody("Response", byteBuf);

@Override
public HttpResponse getResponse() {
 LOG.trace("CommandName: " + COMMAND_NAME + ": getHttpResponse..");
 ByteBuf data = Unpooled.copiedBuffer(responseBody);
 LOG.warn("Response data: {}", Arrays.toString(data.array()));
 FullHttpResponse httpResponse = new DefaultFullHttpResponse(HTTP_1_1, OK, data);
 httpResponse.headers().set(CONTENT_TYPE, CommonEpConstans.RESPONSE_CONTENT_TYPE);
 httpResponse.headers().set(CONTENT_LENGTH, data.readableBytes());
 LOG.warn("Response size: {}", data.readableBytes());
 httpResponse
   .headers()
   .set(CommonEpConstans.RESPONSE_TYPE, CommonEpConstans.RESPONSE_TYPE_OPERATION);
 if (responseSignature != null) {
  httpResponse
    .headers()
    .set(CommonEpConstans.SIGNATURE_HEADER_NAME, encodeBase64String(responseSignature));
 }
 if (isNeedConnectionClose()) {
  httpResponse.headers().set(CONNECTION, HttpHeaders.Values.CLOSE);
 } else {
  if (HttpHeaders.isKeepAlive(getRequest())) {
   httpResponse.headers().set(CONNECTION, HttpHeaders.Values.KEEP_ALIVE);
  } else {
   httpResponse.headers().set(CONNECTION, HttpHeaders.Values.CLOSE);
  }
 }
 return httpResponse;
}

LOG.trace("Attempting to decode DNS record [{}]", dnsRecord);
try {
  final ByteBuf byteBuf = dnsRawRecord.content();
  ipAddressBytes = new byte[byteBuf.readableBytes()];
  int readerIndex = byteBuf.readerIndex();
  byteBuf.getBytes(readerIndex, ipAddressBytes);
} finally {
LOG.trace("The IP address has [{}] bytes", ipAddressBytes.length);
LOG.trace("The resulting IP address is [{}]", ipAddress.getHostAddress());

@Override
public void read(MysqlClientHandler handler, ByteBuf in) {
  int begin = in.readerIndex();
  in.readBytes(nullBitMap);
  int end = in.readerIndex();
  if (_log.isTraceEnabled())
    in.readerIndex(begin);
    byte[] bytes = new byte[end - begin];
    in.readBytes(bytes);
    String dump = '\n' + UberUtil.hexDump(bytes);
    _log.trace("Packet Info:\n"
        + this.toString()
        + "\nTableMapPacket packet:\n" 

protected final void defaultEndGroup() throws HiveException {
 LOG.debug("Ending group");
 if (CollectionUtils.isEmpty(childOperators)) {
  LOG.trace("No children operators; end group done");
  return;
 }
 LOG.trace("Ending group for children");
 for (Operator<? extends OperatorDesc> op : childOperators) {
  op.endGroup();
 }
 LOG.trace("End group done");
}