diff --git a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-otlp.txt b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-otlp.txt index a559852f699..76ceebcd3a4 100644 --- a/docs/apidiffs/current_vs_latest/opentelemetry-exporter-otlp.txt +++ b/docs/apidiffs/current_vs_latest/opentelemetry-exporter-otlp.txt @@ -1,2 +1,25 @@ Comparing source compatibility of opentelemetry-exporter-otlp-1.54.0-SNAPSHOT.jar against opentelemetry-exporter-otlp-1.53.0.jar -No changes. \ No newline at end of file +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogRecordExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogRecordExporterBuilder setThrottlingLoggerRate(double, double) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.http.logs.OtlpHttpLogRecordExporterBuilder setThrottlingLoggerTimeUnit(java.util.concurrent.TimeUnit) +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.otlp.http.metrics.OtlpHttpMetricExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.http.metrics.OtlpHttpMetricExporterBuilder setThrottlingLoggerRate(double, double) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.http.metrics.OtlpHttpMetricExporterBuilder setThrottlingLoggerTimeUnit(java.util.concurrent.TimeUnit) +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.otlp.http.trace.OtlpHttpSpanExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.http.trace.OtlpHttpSpanExporterBuilder setThrottlingLoggerRate(double, double) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.http.trace.OtlpHttpSpanExporterBuilder setThrottlingLoggerTimeUnit(java.util.concurrent.TimeUnit) +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporterBuilder setThrottlingLoggerRate(double, double) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporterBuilder setThrottlingLoggerTimeUnit(java.util.concurrent.TimeUnit) +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporterBuilder setThrottlingLoggerRate(double, double) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporterBuilder setThrottlingLoggerTimeUnit(java.util.concurrent.TimeUnit) +*** MODIFIED CLASS: PUBLIC FINAL io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporterBuilder (not serializable) + === CLASS FILE FORMAT VERSION: 52.0 <- 52.0 + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporterBuilder setThrottlingLoggerRate(double, double) + +++ NEW METHOD: PUBLIC(+) io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporterBuilder setThrottlingLoggerTimeUnit(java.util.concurrent.TimeUnit) diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporter.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporter.java index 3c8de2f541c..8fffa875b4c 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporter.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporter.java @@ -16,6 +16,7 @@ import io.opentelemetry.sdk.common.InternalTelemetryVersion; import io.opentelemetry.sdk.internal.StandardComponentId; import io.opentelemetry.sdk.internal.ThrottlingLogger; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Supplier; import java.util.logging.Level; @@ -32,7 +33,7 @@ public final class GrpcExporter { private static final Logger internalLogger = Logger.getLogger(GrpcExporter.class.getName()); - private final ThrottlingLogger logger = new ThrottlingLogger(internalLogger); + private final ThrottlingLogger logger; // We only log unimplemented once since it's a configuration issue that won't be recovered. private final AtomicBoolean loggedUnimplemented = new AtomicBoolean(); @@ -53,6 +54,24 @@ public GrpcExporter( this.exporterMetrics = new ExporterInstrumentation( internalTelemetryVersion, meterProviderSupplier, componentId, endpoint); + this.logger = new ThrottlingLogger(internalLogger); + } + + public GrpcExporter( + GrpcSender grpcSender, + InternalTelemetryVersion internalTelemetryVersion, + StandardComponentId componentId, + Supplier meterProviderSupplier, + String endpoint, + double rateLimit, + double throttledRateLimit, + TimeUnit rateTimeUnit) { + this.type = componentId.getStandardType().signal().logFriendlyName(); + this.grpcSender = grpcSender; + this.exporterMetrics = + new ExporterInstrumentation( + internalTelemetryVersion, meterProviderSupplier, componentId, endpoint); + this.logger = new ThrottlingLogger(internalLogger, rateLimit, throttledRateLimit, rateTimeUnit); } public CompletableResultCode export(T exportRequest, int numItems) { diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java index 27d06b7116b..4c3731e589d 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/grpc/GrpcExporterBuilder.java @@ -76,6 +76,10 @@ public class GrpcExporterBuilder { // Use Object type since gRPC may not be on the classpath. @Nullable private Object grpcChannel; + private double throttlingLoggerRateLimit = 5; + private double throttlingLoggerThrottledRateLimit = 1; + private TimeUnit throttlingLoggerTimeUnit = TimeUnit.MINUTES; + public GrpcExporterBuilder( StandardComponentId.ExporterType exporterType, long defaultTimeoutSecs, @@ -182,6 +186,17 @@ public GrpcExporterBuilder setExecutorService(ExecutorService executorService return this; } + public GrpcExporterBuilder setLogThrottlingRate(double rateLimit, double throttledRateLimit) { + this.throttlingLoggerRateLimit = rateLimit; + this.throttlingLoggerThrottledRateLimit = throttledRateLimit; + return this; + } + + public GrpcExporterBuilder setLogThrottlingTimeUnit(TimeUnit rateTimeUnit) { + this.throttlingLoggerTimeUnit = rateTimeUnit; + return this; + } + @SuppressWarnings("BuilderReturnThis") public GrpcExporterBuilder copy() { GrpcExporterBuilder copy = @@ -205,6 +220,9 @@ public GrpcExporterBuilder copy() { copy.meterProviderSupplier = meterProviderSupplier; copy.internalTelemetryVersion = internalTelemetryVersion; copy.grpcChannel = grpcChannel; + copy.throttlingLoggerRateLimit = throttlingLoggerRateLimit; + copy.throttlingLoggerThrottledRateLimit = throttlingLoggerThrottledRateLimit; + copy.throttlingLoggerTimeUnit = throttlingLoggerTimeUnit; return copy; } diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporter.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporter.java index 07533a95fea..16d373dae2e 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporter.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporter.java @@ -15,6 +15,7 @@ import io.opentelemetry.sdk.internal.StandardComponentId; import io.opentelemetry.sdk.internal.ThrottlingLogger; import java.io.IOException; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.function.Supplier; import java.util.logging.Level; @@ -32,7 +33,7 @@ public final class HttpExporter { private static final Logger internalLogger = Logger.getLogger(HttpExporter.class.getName()); - private final ThrottlingLogger logger = new ThrottlingLogger(internalLogger); + private final ThrottlingLogger logger; private final AtomicBoolean isShutdown = new AtomicBoolean(); private final String type; @@ -50,6 +51,24 @@ public HttpExporter( this.exporterMetrics = new ExporterInstrumentation( internalTelemetryVersion, meterProviderSupplier, componentId, endpoint); + this.logger = new ThrottlingLogger(internalLogger); + } + + public HttpExporter( + StandardComponentId componentId, + HttpSender httpSender, + Supplier meterProviderSupplier, + InternalTelemetryVersion internalTelemetryVersion, + String endpoint, + double rateLimit, + double throttledRateLimit, + TimeUnit rateTimeUnit) { + this.type = componentId.getStandardType().signal().logFriendlyName(); + this.httpSender = httpSender; + this.exporterMetrics = + new ExporterInstrumentation( + internalTelemetryVersion, meterProviderSupplier, componentId, endpoint); + this.logger = new ThrottlingLogger(internalLogger, rateLimit, throttledRateLimit, rateTimeUnit); } public CompletableResultCode export(T exportRequest, int numItems) { diff --git a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java index 42d55cb0a2c..f7611336e33 100644 --- a/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java +++ b/exporters/common/src/main/java/io/opentelemetry/exporter/internal/http/HttpExporterBuilder.java @@ -70,6 +70,10 @@ public final class HttpExporterBuilder { ComponentLoader.forClassLoader(HttpExporterBuilder.class.getClassLoader()); @Nullable private ExecutorService executorService; + private double throttlingLoggerRateLimit = 5; + private double throttlingLoggerThrottledRateLimit = 1; + private TimeUnit throttlingLoggerTimeUnit = TimeUnit.MINUTES; + public HttpExporterBuilder( StandardComponentId.ExporterType exporterType, String defaultEndpoint) { this.exporterType = exporterType; @@ -187,6 +191,17 @@ private static StandardComponentId.ExporterType mapToJsonTypeIfPossible( } } + public HttpExporterBuilder setLogThrottlingRate(double rateLimit, double throttledRateLimit) { + this.throttlingLoggerRateLimit = rateLimit; + this.throttlingLoggerThrottledRateLimit = throttledRateLimit; + return this; + } + + public HttpExporterBuilder setLogThrottlingTimeUnit(TimeUnit rateTimeUnit) { + this.throttlingLoggerTimeUnit = rateTimeUnit; + return this; + } + @SuppressWarnings("BuilderReturnThis") public HttpExporterBuilder copy() { HttpExporterBuilder copy = new HttpExporterBuilder<>(exporterType, endpoint); @@ -204,6 +219,9 @@ public HttpExporterBuilder copy() { copy.meterProviderSupplier = meterProviderSupplier; copy.internalTelemetryVersion = internalTelemetryVersion; copy.proxyOptions = proxyOptions; + copy.throttlingLoggerRateLimit = throttlingLoggerRateLimit; + copy.throttlingLoggerThrottledRateLimit = throttlingLoggerThrottledRateLimit; + copy.throttlingLoggerTimeUnit = throttlingLoggerTimeUnit; return copy; } diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java index b9606919075..559a78f93b6 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/logs/OtlpHttpLogRecordExporterBuilder.java @@ -275,6 +275,19 @@ public OtlpHttpLogRecordExporterBuilder setExecutorService(ExecutorService execu return this; } + /** Set the initial and throttled rate for the ThrottlingLogger. */ + public OtlpHttpLogRecordExporterBuilder setThrottlingLoggerRate( + double rateLimit, double throttledRateLimit) { + delegate.setLogThrottlingRate(rateLimit, throttledRateLimit); + return this; + } + + /** Set the time unit used for the ThrottlingLogger. */ + public OtlpHttpLogRecordExporterBuilder setThrottlingLoggerTimeUnit(TimeUnit rateTimeUnit) { + delegate.setLogThrottlingTimeUnit(rateTimeUnit); + return this; + } + /** * Constructs a new instance of the exporter based on the builder's values. * diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java index 07f24dac91c..2ec2f8020cc 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/metrics/OtlpHttpMetricExporterBuilder.java @@ -339,6 +339,19 @@ OtlpHttpMetricExporterBuilder exportAsJson() { return this; } + /** Set the initial and throttled rate for the ThrottlingLogger. */ + public OtlpHttpMetricExporterBuilder setThrottlingLoggerRate( + double rateLimit, double throttledRateLimit) { + delegate.setLogThrottlingRate(rateLimit, throttledRateLimit); + return this; + } + + /** Set the time unit used for the ThrottlingLogger. */ + public OtlpHttpMetricExporterBuilder setThrottlingLoggerTimeUnit(TimeUnit rateTimeUnit) { + delegate.setLogThrottlingTimeUnit(rateTimeUnit); + return this; + } + /** * Constructs a new instance of the exporter based on the builder's values. * diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java index f8289010b5b..5465f9de620 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/http/trace/OtlpHttpSpanExporterBuilder.java @@ -276,6 +276,19 @@ public OtlpHttpSpanExporterBuilder setExecutorService(ExecutorService executorSe return this; } + /** Set the initial and throttled rate for the ThrottlingLogger. */ + public OtlpHttpSpanExporterBuilder setThrottlingLoggerRate( + double rateLimit, double throttledRateLimit) { + delegate.setLogThrottlingRate(rateLimit, throttledRateLimit); + return this; + } + + /** Set the time unit used for the ThrottlingLogger. */ + public OtlpHttpSpanExporterBuilder setThrottlingLoggerTimeUnit(TimeUnit rateTimeUnit) { + delegate.setLogThrottlingTimeUnit(rateTimeUnit); + return this; + } + /** * Constructs a new instance of the exporter based on the builder's values. * diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtil.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtil.java index 427d79e7ac4..118b91375f2 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtil.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtil.java @@ -19,7 +19,9 @@ import java.net.URLDecoder; import java.nio.charset.StandardCharsets; import java.time.Duration; +import java.util.Locale; import java.util.Map; +import java.util.concurrent.TimeUnit; import java.util.function.BiConsumer; import java.util.function.Consumer; import java.util.logging.Logger; @@ -62,7 +64,9 @@ public static void configureOtlpExporterBuilder( Consumer setTrustedCertificates, BiConsumer setClientTls, Consumer setRetryPolicy, - Consumer setMemoryMode) { + Consumer setMemoryMode, + BiConsumer setThrottlingLoggerRate, + Consumer setThrottlingLoggerTimeUnit) { setComponentLoader.accept(config.getComponentLoader()); String protocol = getOtlpProtocol(dataType, config); @@ -143,6 +147,27 @@ public static void configureOtlpExporterBuilder( } ExporterBuilderUtil.configureExporterMemoryMode(config, setMemoryMode); + + double logRateStr = config.getDouble("otel.exporter.otlp.lograte", 5); + double logThrottleRateStr = config.getDouble("otel.exporter.otlp.throttledlograte", 1); + setThrottlingLoggerRate.accept(logRateStr, logThrottleRateStr); + + String logTimeUnitStr = config.getString("otel.exporter.otlp.logtimeunit", "MINUTES"); + TimeUnit logTimeUnit; + switch (logTimeUnitStr.toUpperCase(Locale.ROOT)) { + case "SECONDS": + logTimeUnit = TimeUnit.SECONDS; + break; + case "HOURS": + logTimeUnit = TimeUnit.HOURS; + break; + case "DAYS": + logTimeUnit = TimeUnit.DAYS; + break; + default: + logTimeUnit = TimeUnit.MINUTES; + } + setThrottlingLoggerTimeUnit.accept(logTimeUnit); } static void configureOtlpHeaders( diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProvider.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProvider.java index 1262bc7250f..64dd75ca4fc 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProvider.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpLogRecordExporterProvider.java @@ -53,7 +53,9 @@ public LogRecordExporter createExporter(ConfigProperties config) { builder::setTrustedCertificates, builder::setClientTls, builder::setRetryPolicy, - builder::setMemoryMode); + builder::setMemoryMode, + builder::setThrottlingLoggerRate, + builder::setThrottlingLoggerTimeUnit); builder.setMeterProvider(meterProviderRef::get); return builder.build(); @@ -71,7 +73,9 @@ public LogRecordExporter createExporter(ConfigProperties config) { builder::setTrustedCertificates, builder::setClientTls, builder::setRetryPolicy, - builder::setMemoryMode); + builder::setMemoryMode, + builder::setThrottlingLoggerRate, + builder::setThrottlingLoggerTimeUnit); builder.setMeterProvider(meterProviderRef::get); return builder.build(); diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpMetricExporterProvider.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpMetricExporterProvider.java index ebfaaacf296..e4570f1d3cc 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpMetricExporterProvider.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpMetricExporterProvider.java @@ -46,7 +46,9 @@ public MetricExporter createExporter(ConfigProperties config) { builder::setTrustedCertificates, builder::setClientTls, builder::setRetryPolicy, - builder::setMemoryMode); + builder::setMemoryMode, + builder::setThrottlingLoggerRate, + builder::setThrottlingLoggerTimeUnit); ExporterBuilderUtil.configureOtlpAggregationTemporality( config, builder::setAggregationTemporalitySelector); ExporterBuilderUtil.configureOtlpHistogramDefaultAggregation( @@ -67,7 +69,9 @@ public MetricExporter createExporter(ConfigProperties config) { builder::setTrustedCertificates, builder::setClientTls, builder::setRetryPolicy, - builder::setMemoryMode); + builder::setMemoryMode, + builder::setThrottlingLoggerRate, + builder::setThrottlingLoggerTimeUnit); ExporterBuilderUtil.configureOtlpAggregationTemporality( config, builder::setAggregationTemporalitySelector); ExporterBuilderUtil.configureOtlpHistogramDefaultAggregation( diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProvider.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProvider.java index 1561c057b29..e57e03fef57 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProvider.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/internal/OtlpSpanExporterProvider.java @@ -52,7 +52,9 @@ public SpanExporter createExporter(ConfigProperties config) { builder::setTrustedCertificates, builder::setClientTls, builder::setRetryPolicy, - builder::setMemoryMode); + builder::setMemoryMode, + builder::setThrottlingLoggerRate, + builder::setThrottlingLoggerTimeUnit); builder.setMeterProvider(meterProviderRef::get); return builder.build(); @@ -70,7 +72,9 @@ public SpanExporter createExporter(ConfigProperties config) { builder::setTrustedCertificates, builder::setClientTls, builder::setRetryPolicy, - builder::setMemoryMode); + builder::setMemoryMode, + builder::setThrottlingLoggerRate, + builder::setThrottlingLoggerTimeUnit); builder.setMeterProvider(meterProviderRef::get); return builder.build(); diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java index 467aa0cd6a9..6f0b5c4011f 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/logs/OtlpGrpcLogRecordExporterBuilder.java @@ -304,6 +304,19 @@ public OtlpGrpcLogRecordExporterBuilder setExecutorService(ExecutorService execu return this; } + /** Set the initial and throttled rate for the ThrottlingLogger. */ + public OtlpGrpcLogRecordExporterBuilder setThrottlingLoggerRate( + double rateLimit, double throttledRateLimit) { + delegate.setLogThrottlingRate(rateLimit, throttledRateLimit); + return this; + } + + /** Set the time unit used for the ThrottlingLogger. */ + public OtlpGrpcLogRecordExporterBuilder setThrottlingLoggerTimeUnit(TimeUnit rateTimeUnit) { + delegate.setLogThrottlingTimeUnit(rateTimeUnit); + return this; + } + /** * Constructs a new instance of the exporter based on the builder's values. * diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java index ef3403c7353..09f01bd9da7 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/metrics/OtlpGrpcMetricExporterBuilder.java @@ -362,6 +362,19 @@ public OtlpGrpcMetricExporterBuilder setExecutorService(ExecutorService executor return this; } + /** Set the initial and throttled rate for the ThrottlingLogger. */ + public OtlpGrpcMetricExporterBuilder setThrottlingLoggerRate( + double rateLimit, double throttledRateLimit) { + delegate.setLogThrottlingRate(rateLimit, throttledRateLimit); + return this; + } + + /** Set the time unit used for the ThrottlingLogger. */ + public OtlpGrpcMetricExporterBuilder setThrottlingLoggerTimeUnit(TimeUnit rateTimeUnit) { + delegate.setLogThrottlingTimeUnit(rateTimeUnit); + return this; + } + /** * Constructs a new instance of the exporter based on the builder's values. * diff --git a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java index fa7523b5b9e..7c6ccde9952 100644 --- a/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java +++ b/exporters/otlp/all/src/main/java/io/opentelemetry/exporter/otlp/trace/OtlpGrpcSpanExporterBuilder.java @@ -301,6 +301,19 @@ public OtlpGrpcSpanExporterBuilder setExecutorService(ExecutorService executorSe return this; } + /** Set the initial and throttled rate for the ThrottlingLogger. */ + public OtlpGrpcSpanExporterBuilder setThrottlingLoggerRate( + double rateLimit, double throttledRateLimit) { + delegate.setLogThrottlingRate(rateLimit, throttledRateLimit); + return this; + } + + /** Set the time unit used for the ThrottlingLogger. */ + public OtlpGrpcSpanExporterBuilder setThrottlingLoggerTimeUnit(TimeUnit rateTimeUnit) { + delegate.setLogThrottlingTimeUnit(rateTimeUnit); + return this; + } + /** * Constructs a new instance of the exporter based on the builder's values. * diff --git a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java index fb1061ae3fa..65fa0388cb3 100644 --- a/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java +++ b/exporters/otlp/all/src/test/java/io/opentelemetry/exporter/otlp/internal/OtlpConfigUtilTest.java @@ -30,6 +30,7 @@ import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Stream; import javax.annotation.Nullable; @@ -379,6 +380,8 @@ private static String configureEndpoint(String dataType, Map pro value -> {}, (value1, value2) -> {}, value -> {}, + value -> {}, + (value1, value2) -> {}, value -> {}); return endpoint.get(); @@ -467,4 +470,57 @@ private static DefaultAggregationSelector configureHistogramDefaultAggregation( // We apply the temporality selector to a HISTOGRAM instrument to simplify assertions return aggregationRef.get(); } + + @Test + void configureOtlpExporterBuilder_ThrottlingLoggerTimeUnit() { + // Test default value + assertThat(configureThrottlingLoggerTimeUnit(Collections.emptyMap())) + .isEqualTo(TimeUnit.MINUTES); + assertThat( + configureThrottlingLoggerTimeUnit( + ImmutableMap.of("otel.exporter.otlp.logtimeunit", "invalid"))) + .isEqualTo(TimeUnit.MINUTES); + assertThat( + configureThrottlingLoggerTimeUnit( + ImmutableMap.of("otel.exporter.otlp.logtimeunit", "SECONDS"))) + .isEqualTo(TimeUnit.SECONDS); + assertThat( + configureThrottlingLoggerTimeUnit( + ImmutableMap.of("otel.exporter.otlp.logtimeunit", "HOURS"))) + .isEqualTo(TimeUnit.HOURS); + assertThat( + configureThrottlingLoggerTimeUnit( + ImmutableMap.of("otel.exporter.otlp.logtimeunit", "DAYS"))) + .isEqualTo(TimeUnit.DAYS); + assertThat( + configureThrottlingLoggerTimeUnit( + ImmutableMap.of("otel.exporter.otlp.logtimeunit", "MINUTES"))) + .isEqualTo(TimeUnit.MINUTES); + assertThat( + configureThrottlingLoggerTimeUnit( + ImmutableMap.of("otel.exporter.otlp.logtimeunit", "hours"))) + .isEqualTo(TimeUnit.HOURS); + } + + /** Configure and return the time unit. */ + private static TimeUnit configureThrottlingLoggerTimeUnit(Map properties) { + AtomicReference throttlingLoggerTimeUnit = new AtomicReference<>(); + + OtlpConfigUtil.configureOtlpExporterBuilder( + DATA_TYPE_LOGS, + DefaultConfigProperties.createFromMap(properties), + value -> {}, + value -> {}, + (value1, value2) -> {}, + value -> {}, + value -> {}, + value -> {}, + (value1, value2) -> {}, + value -> {}, + value -> {}, + (value1, value2) -> {}, + throttlingLoggerTimeUnit::set); + + return throttlingLoggerTimeUnit.get(); + } }