Examples with Scope io.opentelemetry.context.Scope used on opensource projects

Example 11 with Scope

use of io.opentelemetry.context.Scope in project hbase by apache.

the class MemcachedBlockCache method getBlock.

@Override
public Cacheable getBlock(BlockCacheKey cacheKey, boolean caching, boolean repeat, boolean updateCacheMetrics) {
    // Assume that nothing is the block cache
    HFileBlock result = null;
    Span span = TraceUtil.getGlobalTracer().spanBuilder("MemcachedBlockCache.getBlock").startSpan();
    try (Scope traceScope = span.makeCurrent()) {
        result = client.get(cacheKey.toString(), tc);
    } catch (Exception e) {
        // and how it handles failures from leaking into the read path.
        if (LOG.isDebugEnabled()) {
            LOG.debug("Exception pulling from memcached [ " + cacheKey.toString() + " ]. Treating as a miss.", e);
        }
        result = null;
    } finally {
        span.end();
        // Update stats if this request doesn't have it turned off 100% of the time
        if (updateCacheMetrics) {
            if (result == null) {
                cacheStats.miss(caching, cacheKey.isPrimary(), cacheKey.getBlockType());
            } else {
                cacheStats.hit(caching, cacheKey.isPrimary(), cacheKey.getBlockType());
            }
        }
    }
    return result;
}

Example 12 with Scope

use of io.opentelemetry.context.Scope in project hbase by apache.

the class ServerRpcConnection method processRequest.

/**
 * @param buf
 *          Has the request header and the request param and optionally
 *          encoded data buffer all in this one array.
 * @throws IOException
 * @throws InterruptedException
 */
protected void processRequest(ByteBuff buf) throws IOException, InterruptedException {
    long totalRequestSize = buf.limit();
    int offset = 0;
    // Here we read in the header. We avoid having pb
    // do its default 4k allocation for CodedInputStream. We force it to use
    // backing array.
    CodedInputStream cis;
    if (buf.hasArray()) {
        cis = UnsafeByteOperations.unsafeWrap(buf.array(), 0, buf.limit()).newCodedInput();
    } else {
        cis = UnsafeByteOperations.unsafeWrap(new ByteBuffByteInput(buf, 0, buf.limit()), 0, buf.limit()).newCodedInput();
    }
    cis.enableAliasing(true);
    int headerSize = cis.readRawVarint32();
    offset = cis.getTotalBytesRead();
    Message.Builder builder = RequestHeader.newBuilder();
    ProtobufUtil.mergeFrom(builder, cis, headerSize);
    RequestHeader header = (RequestHeader) builder.build();
    offset += headerSize;
    TextMapGetter<RPCTInfo> getter = new TextMapGetter<RPCTInfo>() {

        @Override
        public Iterable<String> keys(RPCTInfo carrier) {
            return carrier.getHeadersMap().keySet();
        }

        @Override
        public String get(RPCTInfo carrier, String key) {
            return carrier.getHeadersMap().get(key);
        }
    };
    Context traceCtx = GlobalOpenTelemetry.getPropagators().getTextMapPropagator().extract(Context.current(), header.getTraceInfo(), getter);
    Span span = TraceUtil.createRemoteSpan("RpcServer.process", traceCtx);
    try (Scope scope = span.makeCurrent()) {
        int id = header.getCallId();
        if (RpcServer.LOG.isTraceEnabled()) {
            RpcServer.LOG.trace("RequestHeader " + TextFormat.shortDebugString(header) + " totalRequestSize: " + totalRequestSize + " bytes");
        }
        // total request.
        if ((totalRequestSize + this.rpcServer.callQueueSizeInBytes.sum()) > this.rpcServer.maxQueueSizeInBytes) {
            final ServerCall<?> callTooBig = createCall(id, this.service, null, null, null, null, totalRequestSize, null, 0, this.callCleanup);
            this.rpcServer.metrics.exception(RpcServer.CALL_QUEUE_TOO_BIG_EXCEPTION);
            callTooBig.setResponse(null, null, RpcServer.CALL_QUEUE_TOO_BIG_EXCEPTION, "Call queue is full on " + this.rpcServer.server.getServerName() + ", is hbase.ipc.server.max.callqueue.size too small?");
            callTooBig.sendResponseIfReady();
            return;
        }
        MethodDescriptor md = null;
        Message param = null;
        CellScanner cellScanner = null;
        try {
            if (header.hasRequestParam() && header.getRequestParam()) {
                md = this.service.getDescriptorForType().findMethodByName(header.getMethodName());
                if (md == null) {
                    throw new UnsupportedOperationException(header.getMethodName());
                }
                builder = this.service.getRequestPrototype(md).newBuilderForType();
                cis.resetSizeCounter();
                int paramSize = cis.readRawVarint32();
                offset += cis.getTotalBytesRead();
                if (builder != null) {
                    ProtobufUtil.mergeFrom(builder, cis, paramSize);
                    param = builder.build();
                }
                offset += paramSize;
            } else {
                // currently header must have request param, so we directly throw
                // exception here
                String msg = "Invalid request header: " + TextFormat.shortDebugString(header) + ", should have param set in it";
                RpcServer.LOG.warn(msg);
                throw new DoNotRetryIOException(msg);
            }
            if (header.hasCellBlockMeta()) {
                buf.position(offset);
                ByteBuff dup = buf.duplicate();
                dup.limit(offset + header.getCellBlockMeta().getLength());
                cellScanner = this.rpcServer.cellBlockBuilder.createCellScannerReusingBuffers(this.codec, this.compressionCodec, dup);
            }
        } catch (Throwable t) {
            InetSocketAddress address = this.rpcServer.getListenerAddress();
            String msg = (address != null ? address : "(channel closed)") + " is unable to read call parameter from client " + getHostAddress();
            RpcServer.LOG.warn(msg, t);
            this.rpcServer.metrics.exception(t);
            // version
            if (t instanceof LinkageError) {
                t = new DoNotRetryIOException(t);
            }
            // If the method is not present on the server, do not retry.
            if (t instanceof UnsupportedOperationException) {
                t = new DoNotRetryIOException(t);
            }
            ServerCall<?> readParamsFailedCall = createCall(id, this.service, null, null, null, null, totalRequestSize, null, 0, this.callCleanup);
            readParamsFailedCall.setResponse(null, null, t, msg + "; " + t.getMessage());
            readParamsFailedCall.sendResponseIfReady();
            return;
        }
        int timeout = 0;
        if (header.hasTimeout() && header.getTimeout() > 0) {
            timeout = Math.max(this.rpcServer.minClientRequestTimeout, header.getTimeout());
        }
        ServerCall<?> call = createCall(id, this.service, md, header, param, cellScanner, totalRequestSize, this.addr, timeout, this.callCleanup);
        if (!this.rpcServer.scheduler.dispatch(new CallRunner(this.rpcServer, call))) {
            this.rpcServer.callQueueSizeInBytes.add(-1 * call.getSize());
            this.rpcServer.metrics.exception(RpcServer.CALL_QUEUE_TOO_BIG_EXCEPTION);
            call.setResponse(null, null, RpcServer.CALL_QUEUE_TOO_BIG_EXCEPTION, "Call queue is full on " + this.rpcServer.server.getServerName() + ", too many items queued ?");
            call.sendResponseIfReady();
        }
    }
}

Example 13 with Scope

use of io.opentelemetry.context.Scope in project hbase by apache.

the class CallRunner method run.

public void run() {
    try {
        if (call.disconnectSince() >= 0) {
            if (RpcServer.LOG.isDebugEnabled()) {
                RpcServer.LOG.debug(Thread.currentThread().getName() + ": skipped " + call);
            }
            return;
        }
        call.setStartTime(EnvironmentEdgeManager.currentTime());
        if (call.getStartTime() > call.getDeadline()) {
            RpcServer.LOG.warn("Dropping timed out call: " + call);
            this.rpcServer.getMetrics().callTimedOut();
            return;
        }
        this.status.setStatus("Setting up call");
        this.status.setConnection(call.getRemoteAddress().getHostAddress(), call.getRemotePort());
        if (RpcServer.LOG.isTraceEnabled()) {
            Optional<User> remoteUser = call.getRequestUser();
            RpcServer.LOG.trace(call.toShortString() + " executing as " + (remoteUser.isPresent() ? remoteUser.get().getName() : "NULL principal"));
        }
        Throwable errorThrowable = null;
        String error = null;
        Pair<Message, CellScanner> resultPair = null;
        RpcServer.CurCall.set(call);
        Span span = new IpcServerSpanBuilder(call).build();
        try (Scope traceScope = span.makeCurrent()) {
            if (!this.rpcServer.isStarted()) {
                InetSocketAddress address = rpcServer.getListenerAddress();
                throw new ServerNotRunningYetException("Server " + (address != null ? address : "(channel closed)") + " is not running yet");
            }
            // make the call
            resultPair = this.rpcServer.call(call, this.status);
        } catch (TimeoutIOException e) {
            RpcServer.LOG.warn("Can not complete this request in time, drop it: " + call);
            TraceUtil.setError(span, e);
            return;
        } catch (Throwable e) {
            TraceUtil.setError(span, e);
            if (e instanceof ServerNotRunningYetException) {
                // If ServerNotRunningYetException, don't spew stack trace.
                if (RpcServer.LOG.isTraceEnabled()) {
                    RpcServer.LOG.trace(call.toShortString(), e);
                }
            } else {
                // Don't dump full exception.. just String version
                RpcServer.LOG.debug(call.toShortString() + ", exception=" + e);
            }
            errorThrowable = e;
            error = StringUtils.stringifyException(e);
            if (e instanceof Error) {
                throw (Error) e;
            }
        } finally {
            RpcServer.CurCall.set(null);
            if (resultPair != null) {
                this.rpcServer.addCallSize(call.getSize() * -1);
                span.setStatus(StatusCode.OK);
                sucessful = true;
            }
            span.end();
        }
        this.status.markComplete("To send response");
        // return back the RPC request read BB we can do here. It is done by now.
        call.cleanup();
        // Set the response
        Message param = resultPair != null ? resultPair.getFirst() : null;
        CellScanner cells = resultPair != null ? resultPair.getSecond() : null;
        call.setResponse(param, cells, errorThrowable, error);
        call.sendResponseIfReady();
    } catch (OutOfMemoryError e) {
        if (this.rpcServer.getErrorHandler() != null) {
            if (this.rpcServer.getErrorHandler().checkOOME(e)) {
                RpcServer.LOG.info(Thread.currentThread().getName() + ": exiting on OutOfMemoryError");
                return;
            }
        } else {
            // rethrow if no handler
            throw e;
        }
    } catch (ClosedChannelException cce) {
        InetSocketAddress address = rpcServer.getListenerAddress();
        RpcServer.LOG.warn(Thread.currentThread().getName() + ": caught a ClosedChannelException, " + "this means that the server " + (address != null ? address : "(channel closed)") + " was processing a request but the client went away. The error message was: " + cce.getMessage());
    } catch (Exception e) {
        RpcServer.LOG.warn(Thread.currentThread().getName() + ": caught: " + StringUtils.stringifyException(e));
    } finally {
        if (!sucessful) {
            this.rpcServer.addCallSize(call.getSize() * -1);
        }
        if (this.status.isRPCRunning()) {
            this.status.markComplete("Call error");
        }
        this.status.pause("Waiting for a call");
        cleanup();
    }
}

Example 14 with Scope

use of io.opentelemetry.context.Scope in project hbase by apache.

the class MemStoreFlusher method reclaimMemStoreMemory.

/**
 * 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() {
    Span span = TraceUtil.getGlobalTracer().spanBuilder("MemStoreFluser.reclaimMemStoreMemory").startSpan();
    try (Scope scope = span.makeCurrent()) {
        FlushType flushType = isAboveHighWaterMark();
        if (flushType != FlushType.NORMAL) {
            span.addEvent("Force Flush. We're above high water mark.");
            long start = EnvironmentEdgeManager.currentTime();
            long nextLogTimeMs = start;
            synchronized (this.blockSignal) {
                boolean blocked = false;
                long startTime = 0;
                boolean interrupted = false;
                try {
                    flushType = isAboveHighWaterMark();
                    while (flushType != FlushType.NORMAL && !server.isStopped()) {
                        if (!blocked) {
                            startTime = EnvironmentEdgeManager.currentTime();
                            if (!server.getRegionServerAccounting().isOffheap()) {
                                logMsg("global memstore heapsize", server.getRegionServerAccounting().getGlobalMemStoreHeapSize(), server.getRegionServerAccounting().getGlobalMemStoreLimit());
                            } else {
                                switch(flushType) {
                                    case ABOVE_OFFHEAP_HIGHER_MARK:
                                        logMsg("the global offheap memstore datasize", server.getRegionServerAccounting().getGlobalMemStoreOffHeapSize(), server.getRegionServerAccounting().getGlobalMemStoreLimit());
                                        break;
                                    case ABOVE_ONHEAP_HIGHER_MARK:
                                        logMsg("global memstore heapsize", server.getRegionServerAccounting().getGlobalMemStoreHeapSize(), server.getRegionServerAccounting().getGlobalOnHeapMemStoreLimit());
                                        break;
                                    default:
                                        break;
                                }
                            }
                        }
                        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 nowMs = EnvironmentEdgeManager.currentTime();
                        if (nowMs >= nextLogTimeMs) {
                            LOG.warn("Memstore is above high water mark and block {} ms", nowMs - start);
                            nextLogTimeMs = nowMs + 1000;
                        }
                        flushType = isAboveHighWaterMark();
                    }
                } 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 {
            flushType = isAboveLowWaterMark();
            if (flushType != FlushType.NORMAL) {
                wakeupFlushThread();
            }
            span.end();
        }
    }
}

Example 15 with Scope

use of io.opentelemetry.context.Scope in project hbase by apache.

the class IntegrationTestSendTraceRequests method doGets.

private void doGets(ExecutorService service, final LinkedBlockingQueue<Long> rowKeys) throws IOException {
    for (int i = 0; i < 100; i++) {
        Runnable runnable = new Runnable() {

            private final LinkedBlockingQueue<Long> rowKeyQueue = rowKeys;

            @Override
            public void run() {
                Table ht = null;
                try {
                    ht = util.getConnection().getTable(tableName);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                long accum = 0;
                for (int x = 0; x < 5; x++) {
                    Span span = TraceUtil.getGlobalTracer().spanBuilder("gets").startSpan();
                    try (Scope scope = span.makeCurrent()) {
                        long rk = rowKeyQueue.take();
                        Result r1 = ht.get(new Get(Bytes.toBytes(rk)));
                        if (r1 != null) {
                            accum |= Bytes.toLong(r1.getRow());
                        }
                        Result r2 = ht.get(new Get(Bytes.toBytes(rk)));
                        if (r2 != null) {
                            accum |= Bytes.toLong(r2.getRow());
                        }
                        span.addEvent("Accum = " + accum);
                    } catch (IOException | InterruptedException ie) {
                    // IGNORED
                    } finally {
                        span.end();
                    }
                }
            }
        };
        service.submit(runnable);
    }
}