Java Trace.isTracing方法代码示例

import org.apache.htrace.Trace; //导入方法依赖的package包/类
public static RpcRequestHeaderProto makeRpcRequestHeader(RPC.RpcKind rpcKind,
    RpcRequestHeaderProto.OperationProto operation, int callId,
    int retryCount, byte[] uuid) {
  RpcRequestHeaderProto.Builder result = RpcRequestHeaderProto.newBuilder();
  result.setRpcKind(convert(rpcKind)).setRpcOp(operation).setCallId(callId)
      .setRetryCount(retryCount).setClientId(ByteString.copyFrom(uuid));

  // Add tracing info if we are currently tracing.
  if (Trace.isTracing()) {
    Span s = Trace.currentSpan();
    result.setTraceInfo(RPCTraceInfoProto.newBuilder()
        .setParentId(s.getSpanId())
        .setTraceId(s.getTraceId()).build());
  }

  return result.build();
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
@Override
public Object invoke(Object proxy, Method method, Object[] args)
  throws Throwable {
  long startTime = 0;
  if (LOG.isDebugEnabled()) {
    startTime = Time.now();
  }
  TraceScope traceScope = null;
  if (Trace.isTracing()) {
    traceScope = Trace.startSpan(RpcClientUtil.methodToTraceString(method));
  }
  ObjectWritable value;
  try {
    value = (ObjectWritable)
      client.call(RPC.RpcKind.RPC_WRITABLE, new Invocation(method, args),
        remoteId, fallbackToSimpleAuth);
  } finally {
    if (traceScope != null) traceScope.close();
  }
  if (LOG.isDebugEnabled()) {
    long callTime = Time.now() - startTime;
    LOG.debug("Call: " + method.getName() + " " + callTime);
  }
  return value.get();
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
MemStoreScanner(long readPoint) {
  super();

  this.readPoint = readPoint;
  cellSetAtCreation = cellSet;
  snapshotAtCreation = snapshot;
  if (allocator != null) {
    this.allocatorAtCreation = allocator;
    this.allocatorAtCreation.incScannerCount();
  }
  if (snapshotAllocator != null) {
    this.snapshotAllocatorAtCreation = snapshotAllocator;
    this.snapshotAllocatorAtCreation.incScannerCount();
  }
  if (Trace.isTracing() && Trace.currentSpan() != null) {
    Trace.currentSpan().addTimelineAnnotation("Creating MemStoreScanner");
  }
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
/**
 * Initializes the client credentials for the current request.
 * @param user
 * @param remoteAddress
 * @param service
 */
public static void set(User user,
    InetAddress remoteAddress, BlockingService service) {
  RequestContext ctx = instance.get();
  ctx.user = user;
  ctx.remoteAddress = remoteAddress;
  ctx.service = service;
  ctx.inRequest = true;
  if (Trace.isTracing()) {
    if (user != null) {
      Trace.currentSpan().addKVAnnotation(Bytes.toBytes("user"), Bytes.toBytes(user.getName()));
    }
    if (remoteAddress != null) {
      Trace.currentSpan().addKVAnnotation(
          Bytes.toBytes("remoteAddress"),
          Bytes.toBytes(remoteAddress.getHostAddress()));
    }
  }
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
@Override
public void releaseShortCircuitFds(SlotId slotId) throws IOException {
  ReleaseShortCircuitAccessRequestProto.Builder builder =
      ReleaseShortCircuitAccessRequestProto.newBuilder().
      setSlotId(PBHelper.convert(slotId));
  if (Trace.isTracing()) {
    Span s = Trace.currentSpan();
    builder.setTraceInfo(DataTransferTraceInfoProto.newBuilder()
        .setTraceId(s.getTraceId()).setParentId(s.getSpanId()));
  }
  ReleaseShortCircuitAccessRequestProto proto = builder.build();
  send(out, Op.RELEASE_SHORT_CIRCUIT_FDS, proto);
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
@Override
public void requestShortCircuitShm(String clientName) throws IOException {
  ShortCircuitShmRequestProto.Builder builder =
      ShortCircuitShmRequestProto.newBuilder().
      setClientName(clientName);
  if (Trace.isTracing()) {
    Span s = Trace.currentSpan();
    builder.setTraceInfo(DataTransferTraceInfoProto.newBuilder()
        .setTraceId(s.getTraceId()).setParentId(s.getSpanId()));
  }
  ShortCircuitShmRequestProto proto = builder.build();
  send(out, Op.REQUEST_SHORT_CIRCUIT_SHM, proto);
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
static BaseHeaderProto buildBaseHeader(ExtendedBlock blk,
    Token<BlockTokenIdentifier> blockToken) {
  BaseHeaderProto.Builder builder =  BaseHeaderProto.newBuilder()
    .setBlock(PBHelper.convert(blk))
    .setToken(PBHelper.convert(blockToken));
  if (Trace.isTracing()) {
    Span s = Trace.currentSpan();
    builder.setTraceInfo(DataTransferTraceInfoProto.newBuilder()
        .setTraceId(s.getTraceId())
        .setParentId(s.getSpanId()));
  }
  return builder.build();
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
/**
 * Get a row lock for the specified row. All locks are reentrant. Before calling this function
 * make sure that a region operation has already been started (the calling thread has already
 * acquired the region-close-guard lock).
 *
 * @param row      The row actions will be performed against
 * @param readLock is the lock reader or writer. True indicates that a non-exlcusive lock is
 *                 requested
 */
public RowLock getRowLock(byte[] row, boolean readLock) throws IOException {
  // Make sure the row is inside of this region before getting the lock for
  // it.
  checkRow(row, "row lock");
  // create an object to use a a key in the row lock map
  HashedBytes rowKey = new HashedBytes(row);

  RowLockContext rowLockContext = null;
  RowLockImpl result = null;
  TraceScope traceScope = null;

  // If we're tracing start a span to show how long this took.
  if (Trace.isTracing()) {
    traceScope = Trace.startSpan("HRegion.getRowLock");
    traceScope.getSpan()
        .addTimelineAnnotation("Getting a " + (readLock ? "readLock" : "writeLock"));
  }

  try {
    // Keep trying until we have a lock or error out.
    // TODO: do we need to add a time component here?
    while (result == null) {

      // Try adding a RowLockContext to the lockedRows.
      // If we can add it then there's no other transactions currently
      // running.
      rowLockContext = new RowLockContext(rowKey);
      RowLockContext existingContext = lockedRows.putIfAbsent(rowKey, rowLockContext);

      // if there was a running transaction then there's already a context.
      if (existingContext != null) {
        rowLockContext = existingContext;
      }

      // Now try an get the lock.
      //
      // This can fail as
      if (readLock) {
        result = rowLockContext.newReadLock();
      } else {
        result = rowLockContext.newWriteLock();
      }
    }
    if (!result.getLock().tryLock(this.rowLockWaitDuration, TimeUnit.MILLISECONDS)) {
      if (traceScope != null) {
        traceScope.getSpan().addTimelineAnnotation("Failed to get row lock");
      }
      result = null;
      // Clean up the counts just in case this was the thing keeping the
      // context alive.
      rowLockContext.cleanUp();
      throw new IOException("Timed out waiting for lock for row: " + rowKey);
    }
    return result;
  } catch (InterruptedException ie) {
    LOG.warn("Thread interrupted waiting for lock on row: " + rowKey);
    InterruptedIOException iie = new InterruptedIOException();
    iie.initCause(ie);
    if (traceScope != null) {
      traceScope.getSpan().addTimelineAnnotation("Interrupted exception getting row lock");
    }
    Thread.currentThread().interrupt();
    throw iie;
  } finally {
    if (traceScope != null) {
      traceScope.close();
    }
  }
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
/**
 * Check if the regionserver's memstore memory usage is greater than the
 * limit. If so, flush regions with the biggest memstores until we're down
 * to the lower limit. This method blocks callers until we're down to a safe
 * amount of memstore consumption.
 */
public void reclaimMemStoreMemory() {
  TraceScope scope = Trace.startSpan("MemStoreFluser.reclaimMemStoreMemory");
  if (isAboveHighWaterMark()) {
    if (Trace.isTracing()) {
      scope.getSpan().addTimelineAnnotation("Force Flush. We're above high water mark.");
    }
    long start = EnvironmentEdgeManager.currentTime();
    synchronized (this.blockSignal) {
      boolean blocked = false;
      long startTime = 0;
      boolean interrupted = false;
      try {
        while (isAboveHighWaterMark() && !server.isStopped()) {
          if (!blocked) {
            startTime = EnvironmentEdgeManager.currentTime();
            LOG.info("Blocking updates on "
                + server.toString()
                + ": the global memstore size "
                + TraditionalBinaryPrefix.long2String(server.getRegionServerAccounting()
                    .getGlobalMemstoreSize(), "", 1) + " is >= than blocking "
                + TraditionalBinaryPrefix.long2String(globalMemStoreLimit, "", 1) + " size");
          }
          blocked = true;
          wakeupFlushThread();
          try {
            // we should be able to wait forever, but we've seen a bug where
            // we miss a notify, so put a 5 second bound on it at least.
            blockSignal.wait(5 * 1000);
          } catch (InterruptedException ie) {
            LOG.warn("Interrupted while waiting");
            interrupted = true;
          }
          long took = EnvironmentEdgeManager.currentTime() - start;
          LOG.warn("Memstore is above high water mark and block " + took + "ms");
        }
      } finally {
        if (interrupted) {
          Thread.currentThread().interrupt();
        }
      }

      if(blocked){
        final long totalTime = EnvironmentEdgeManager.currentTime() - startTime;
        if(totalTime > 0){
          this.updatesBlockedMsHighWater.add(totalTime);
        }
        LOG.info("Unblocking updates for server " + server.toString());
      }
    }
  } else if (isAboveLowWaterMark()) {
    wakeupFlushThread();
  }
  scope.close();
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
/**
 * Write request to channel
 *
 * @param call    to write
 */
private void writeRequest(final AsyncCall call) {
  try {
    final RPCProtos.RequestHeader.Builder requestHeaderBuilder = RPCProtos.RequestHeader
        .newBuilder();
    requestHeaderBuilder.setCallId(call.id)
            .setMethodName(call.method.getName()).setRequestParam(call.param != null);

    if (Trace.isTracing()) {
      Span s = Trace.currentSpan();
      requestHeaderBuilder.setTraceInfo(TracingProtos.RPCTInfo.newBuilder().
          setParentId(s.getSpanId()).setTraceId(s.getTraceId()));
    }

    ByteBuffer cellBlock = client.buildCellBlock(call.controller.cellScanner());
    if (cellBlock != null) {
      final RPCProtos.CellBlockMeta.Builder cellBlockBuilder = RPCProtos.CellBlockMeta
          .newBuilder();
      cellBlockBuilder.setLength(cellBlock.limit());
      requestHeaderBuilder.setCellBlockMeta(cellBlockBuilder.build());
    }
    // Only pass priority if there one.  Let zero be same as no priority.
    if (call.controller.getPriority() != 0) {
      requestHeaderBuilder.setPriority(call.controller.getPriority());
    }

    RPCProtos.RequestHeader rh = requestHeaderBuilder.build();

    int totalSize = IPCUtil.getTotalSizeWhenWrittenDelimited(rh, call.param);
    if (cellBlock != null) {
      totalSize += cellBlock.remaining();
    }

    ByteBuf b = channel.alloc().directBuffer(4 + totalSize);
    try(ByteBufOutputStream out = new ByteBufOutputStream(b)) {
      call.callStats.setRequestSizeBytes(IPCUtil.write(out, rh, call.param, cellBlock));
    }

    channel.writeAndFlush(b).addListener(new CallWriteListener(this, call.id));
  } catch (IOException e) {
    close(e);
  }
}
 

import org.apache.htrace.Trace; //导入方法依赖的package包/类
/**
 * Check if the regionserver's memstore memory usage is greater than the
 * limit. If so, flush regions with the biggest memstores until we're down
 * to the lower limit. This method blocks callers until we're down to a safe
 * amount of memstore consumption.
 */
public void reclaimMemStoreMemory() {
  TraceScope scope = Trace.startSpan("MemStoreFluser.reclaimMemStoreMemory");
  if (isAboveHighWaterMark()) {
    if (Trace.isTracing()) {
      scope.getSpan().addTimelineAnnotation("Force Flush. We're above high water mark.");
    }
    long start = EnvironmentEdgeManager.currentTime();
    synchronized (this.blockSignal) {
      boolean blocked = false;
      long startTime = 0;
      boolean interrupted = false;
      try {
        while (isAboveHighWaterMark() && !server.isStopped()) {
          if (!blocked) {
            startTime = EnvironmentEdgeManager.currentTime();
            LOG.info("Blocking updates on " + server.toString() +
              ": the global memstore size " +
              StringUtils.humanReadableInt(server.getRegionServerAccounting().getGlobalMemstoreSize()) +
              " is >= than blocking " +
              StringUtils.humanReadableInt(globalMemStoreLimit) + " size");
          }
          blocked = true;
          wakeupFlushThread();
          try {
            // we should be able to wait forever, but we've seen a bug where
            // we miss a notify, so put a 5 second bound on it at least.
            blockSignal.wait(5 * 1000);
          } catch (InterruptedException ie) {
            LOG.warn("Interrupted while waiting");
            interrupted = true;
          }
          long took = EnvironmentEdgeManager.currentTime() - start;
          LOG.warn("Memstore is above high water mark and block " + took + "ms");
        }
      } finally {
        if (interrupted) {
          Thread.currentThread().interrupt();
        }
      }

      if(blocked){
        final long totalTime = EnvironmentEdgeManager.currentTime() - startTime;
        if(totalTime > 0){
          this.updatesBlockedMsHighWater.add(totalTime);
        }
        LOG.info("Unblocking updates for server " + server.toString());
      }
    }
  } else if (isAboveLowWaterMark()) {
    wakeupFlushThread();
  }
  scope.close();
}