pinpoint-apm/pinpoint · error

INTERNAL

INTERNAL

Error message

export failed

What it means

Error path in GrpcOtlpTraceService.export: the OTLP span export task failed (worker pool rejection surfaces as UNAVAILABLE for backpressure, or mapping/insert threw), so the export request could not complete.

Solutions

1. Scale the worker executor/queue to handle export load
2. Verify trace storage availability and inspect the chained cause
3. Let clients retry on UNAVAILABLE per gRPC retry semantics for transient saturation

When it happens

Trigger: Thrown at otlptrace/otlptrace-collector/src/main/java/com/navercorp/pinpoint/otlp/trace/collector/service/GrpcOtlpTraceService.java:101 when the library encounters an invalid state.

Common situations: See trigger scenarios.

AI-assisted analysis of pinpoint-apm/pinpoint@744c3d3075 (2026-09-07). Data as JSON: /api/errors/c9be674ac8d47901. Report an issue: GitHub.

Appendix: source

Thrown at otlptrace/otlptrace-collector/src/main/java/com/navercorp/pinpoint/otlp/trace/collector/service/GrpcOtlpTraceService.java:101

        // Offload the mapping/insert work onto the worker pool so the gRPC handler thread
        // (server.executor) is not blocked. A saturated worker queue surfaces to the client
        // as UNAVAILABLE (retryable), providing backpressure instead of dropping spans.
        final Context current = Context.current();
        final Runnable exportTask = current.wrap(() -> {
            try {
                if (Context.current().isCancelled()) {
                    // Client already gave up (deadline exceeded / cancelled) before this task ran.
                    // Skip the wasted mapping/insert; the admission reservation is freed in finally.
                    return;
                }
                handleExport(resourceSpanList, responseObserver);
            } catch (Throwable t) {
                // Unexpected failure (e.g. mapping fault on malformed input). Without this catch the
                // exception would escape to the worker thread: the response would never be closed
                // (client hangs until deadline) and the worker thread would die on an uncaught error.
                // INTERNAL is non-retryable, avoiding a retry storm on deterministic (poison-data) faults.
                logger.warn("Unexpected error while exporting otlp trace", t);
                safeOnError(responseObserver, Status.INTERNAL.withDescription("export failed"));
            } finally {
                admissionBytes.release(requestBytes);
            }
        });
        try {
            workerExecutor.execute(exportTask);
        } catch (RejectedExecutionException e) {
            admissionBytes.release(requestBytes);
            logger.warn("Failed to export. Worker executor rejected.");
            ingestMetrics.requestRejected(OtlpTraceIngestMetrics.Transport.GRPC, OtlpTraceIngestMetrics.RequestRejectReason.EXECUTOR_REJECTED);
            safeOnError(responseObserver, EXECUTOR_REJECTED);
        }
    }

    private void handleExport(List<ResourceSpans> resourceSpanList, StreamObserver<ExportTraceServiceResponse> responseObserver) {
        final OtlpTraceExportResult result = exportService.export(resourceSpanList, OtlpTraceIngestMetrics.Transport.GRPC);

        if (OtlpTraceResponseMapper.isServerError(result)) {

View on GitHub (pinned to 744c3d3075)