exceptionfactory commented on code in PR #7830: URL: https://github.com/apache/nifi/pull/7830#discussion_r1344048364
########## nifi-nar-bundles/nifi-opentelemetry-bundle/nifi-opentelemetry-processors/src/main/java/org/apache/nifi/processors/opentelemetry/encoding/TelemetryMessageSerializer.java: ########## @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.processors.opentelemetry.encoding; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.google.protobuf.ByteString; +import com.google.protobuf.Descriptors; +import com.hubspot.jackson.datatype.protobuf.ProtobufJacksonConfig; +import com.hubspot.jackson.datatype.protobuf.builtin.serializers.MessageSerializer; +import org.apache.commons.codec.binary.Hex; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * OpenTelemetry extension of Protobuf Message Serializer supporting OTLP 1.0.0 customization of selected fields + */ +public class TelemetryMessageSerializer extends MessageSerializer { + private static final Set<String> HEXADECIMAL_BYTE_STRING_FIELDS = Arrays.stream(HexadecimalByteStringField.values()) + .map(HexadecimalByteStringField::getField) + .collect(Collectors.toSet()); + + protected TelemetryMessageSerializer(final ProtobufJacksonConfig config) { + super(config); + } + + /** + * Write value as JSON with hexadecimal encoding for selected ByteString fields + * + * @param field Message Field Decriptor Review Comment: This is a singular `Field` object, even `Descriptors` is the enclosing class, are you saying the description should be `Message Field Descriptors`? ########## nifi-nar-bundles/nifi-opentelemetry-bundle/nifi-opentelemetry-processors/src/main/java/org/apache/nifi/processors/opentelemetry/encoding/TelemetryMessageSerializer.java: ########## @@ -0,0 +1,74 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.processors.opentelemetry.encoding; + +import com.fasterxml.jackson.core.JsonGenerator; +import com.fasterxml.jackson.databind.SerializerProvider; +import com.google.protobuf.ByteString; +import com.google.protobuf.Descriptors; +import com.hubspot.jackson.datatype.protobuf.ProtobufJacksonConfig; +import com.hubspot.jackson.datatype.protobuf.builtin.serializers.MessageSerializer; +import org.apache.commons.codec.binary.Hex; + +import java.io.IOException; +import java.util.Arrays; +import java.util.Set; +import java.util.stream.Collectors; + +/** + * OpenTelemetry extension of Protobuf Message Serializer supporting OTLP 1.0.0 customization of selected fields + */ +public class TelemetryMessageSerializer extends MessageSerializer { + private static final Set<String> HEXADECIMAL_BYTE_STRING_FIELDS = Arrays.stream(HexadecimalByteStringField.values()) + .map(HexadecimalByteStringField::getField) + .collect(Collectors.toSet()); + + protected TelemetryMessageSerializer(final ProtobufJacksonConfig config) { + super(config); + } + + /** + * Write value as JSON with hexadecimal encoding for selected ByteString fields + * + * @param field Message Field Decriptor + * @param value Value to be serialized + * @param generator JSON Generator + * @param serializerProvider JSON Serializer Provider + * @throws IOException Thrown on failures serializing values + */ + @Override + protected void writeValue( + Descriptors.FieldDescriptor field, + Object value, + JsonGenerator generator, + SerializerProvider serializerProvider + ) throws IOException { + final String jsonName = field.getJsonName(); + if (HEXADECIMAL_BYTE_STRING_FIELDS.contains(jsonName)) { + final ByteString byteString = (ByteString) value; + final String encoded = getEncodedByteString(byteString); + generator.writeString(encoded); + } else { + super.writeValue(field, value, generator, serializerProvider); + } + } + + private String getEncodedByteString(final ByteString byteString) { + final byte[] bytes = byteString.toByteArray(); Review Comment: Good suggestion! These values are short, usually 16 bytes or less, and the actual efficiency depends on the concrete type of the `ByteString`, but it is worth making the adjustment. ########## nifi-nar-bundles/nifi-opentelemetry-bundle/nifi-opentelemetry-processors/src/main/java/org/apache/nifi/processors/opentelemetry/io/StandardRequestContentListener.java: ########## @@ -0,0 +1,269 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.processors.opentelemetry.io; + +import com.google.protobuf.Message; +import io.opentelemetry.proto.collector.logs.v1.ExportLogsServiceRequest; +import io.opentelemetry.proto.collector.metrics.v1.ExportMetricsServiceRequest; +import io.opentelemetry.proto.collector.trace.v1.ExportTraceServiceRequest; +import io.opentelemetry.proto.common.v1.AnyValue; +import io.opentelemetry.proto.common.v1.KeyValue; +import io.opentelemetry.proto.logs.v1.ResourceLogs; +import io.opentelemetry.proto.metrics.v1.ResourceMetrics; +import io.opentelemetry.proto.resource.v1.Resource; +import io.opentelemetry.proto.trace.v1.ResourceSpans; +import org.apache.nifi.logging.ComponentLog; +import org.apache.nifi.processors.opentelemetry.encoding.JsonServiceRequestReader; +import org.apache.nifi.processors.opentelemetry.encoding.ProtobufServiceRequestReader; +import org.apache.nifi.processors.opentelemetry.encoding.ServiceRequestReader; +import org.apache.nifi.processors.opentelemetry.protocol.ServiceRequestDescription; +import org.apache.nifi.processors.opentelemetry.protocol.ServiceResponse; +import org.apache.nifi.processors.opentelemetry.protocol.ServiceResponseStatus; +import org.apache.nifi.processors.opentelemetry.protocol.TelemetryContentEncoding; +import org.apache.nifi.processors.opentelemetry.protocol.TelemetryContentType; +import org.apache.nifi.processors.opentelemetry.protocol.TelemetryRequestType; +import org.apache.nifi.stream.io.StreamUtils; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.BlockingQueue; +import java.util.zip.GZIPInputStream; + +/** + * Standard implementation of OTLP Request Content Listener supporting available Request and Content Types + */ +public class StandardRequestContentListener implements RequestContentListener { + private static final int ZERO_MESSAGES = 0; + + private static final byte COMPRESSED = 1; + + private static final String CLIENT_SOCKET_ADDRESS = "client.socket.address"; + + private static final String CLIENT_SOCKET_PORT = "client.socket.port"; + + private final ServiceRequestReader protobufReader = new ProtobufServiceRequestReader(); + + private final ServiceRequestReader jsonReader = new JsonServiceRequestReader(); + + private final ComponentLog log; + + private final BlockingQueue<Message> messages; + + public StandardRequestContentListener(final ComponentLog log, final BlockingQueue<Message> messages) { + this.log = Objects.requireNonNull(log, "Log required"); + this.messages = Objects.requireNonNull(messages, "Messages required"); + } + + /** + * Process Request Buffer supporting serialized Protobuf or JSON + * + * @param buffer Request Content Buffer to be processed + * @param serviceRequestDescription Service Request Description describes reader attributes + * @return Service Response with processing status + */ + @Override + public ServiceResponse onRequest(final ByteBuffer buffer, final ServiceRequestDescription serviceRequestDescription) { + Objects.requireNonNull(buffer, "Buffer required"); + Objects.requireNonNull(serviceRequestDescription, "Description required"); + + ServiceResponse serviceResponse; + + final InetSocketAddress remoteAddress = serviceRequestDescription.getRemoteAddress(); + final TelemetryContentType contentType = serviceRequestDescription.getContentType(); + if (TelemetryContentType.APPLICATION_GRPC == contentType) { + try { + final byte compression = buffer.get(); + final int messageSize = buffer.getInt(); + log.debug("Client Address [{}] Content-Type [{}] Message Size [{}] Compression [{}]", remoteAddress, contentType, messageSize, compression); + + final ByteBuffer messageBuffer; + if (COMPRESSED == compression) { + messageBuffer = getDecompressedBuffer(buffer); Review Comment: Good question, although messages should generally be of a reasonable size, the decompression process could expand the input size in a notable way. The default behavior of the Java Agent does not enable Gzip compression, but that can be tested by setting `-Dotel.exporter.otlp.compression=gzip`. In light of other notes, I have refactored the approach to pass the wrapping `GZIPInputStream`, instead of reading everything to a new buffer, which should help. ########## nifi-nar-bundles/nifi-opentelemetry-bundle/nifi-opentelemetry-processors/src/main/java/org/apache/nifi/processors/opentelemetry/ListenOTLP.java: ########## @@ -0,0 +1,241 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.processors.opentelemetry; + +import com.google.protobuf.Message; +import org.apache.nifi.annotation.behavior.InputRequirement; +import org.apache.nifi.annotation.behavior.WritesAttribute; +import org.apache.nifi.annotation.behavior.WritesAttributes; +import org.apache.nifi.annotation.configuration.DefaultSchedule; +import org.apache.nifi.annotation.documentation.CapabilityDescription; +import org.apache.nifi.annotation.documentation.Tags; +import org.apache.nifi.annotation.lifecycle.OnScheduled; +import org.apache.nifi.annotation.lifecycle.OnStopped; +import org.apache.nifi.components.PropertyDescriptor; +import org.apache.nifi.event.transport.EventServer; +import org.apache.nifi.event.transport.EventServerFactory; +import org.apache.nifi.event.transport.netty.NettyEventServerFactory; +import org.apache.nifi.expression.ExpressionLanguageScope; +import org.apache.nifi.flowfile.FlowFile; +import org.apache.nifi.processors.opentelemetry.protocol.TelemetryAttributeName; +import org.apache.nifi.processors.opentelemetry.io.RequestCallback; +import org.apache.nifi.processors.opentelemetry.io.RequestCallbackProvider; +import org.apache.nifi.processors.opentelemetry.server.HttpServerFactory; +import org.apache.nifi.processor.AbstractProcessor; +import org.apache.nifi.processor.ProcessContext; +import org.apache.nifi.processor.ProcessSession; +import org.apache.nifi.processor.Relationship; +import org.apache.nifi.processor.exception.ProcessException; +import org.apache.nifi.processor.util.StandardValidators; +import org.apache.nifi.security.util.ClientAuth; +import org.apache.nifi.ssl.SSLContextService; + +import javax.net.ssl.SSLContext; +import java.net.InetAddress; +import java.net.URI; +import java.net.UnknownHostException; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Set; +import java.util.concurrent.BlockingQueue; +import java.util.concurrent.LinkedBlockingQueue; + +@InputRequirement(InputRequirement.Requirement.INPUT_FORBIDDEN) +@DefaultSchedule(period = "25 ms") +@Tags({"OpenTelemetry", "OTel", "OTLP", "telemetry", "metrics", "traces", "logs"}) +@CapabilityDescription( + "Collect OpenTelemetry messages over HTTP or gRPC. " + + "Supports standard Export Service Request messages for logs, metrics, and traces. " + + "Implements OpenTelemetry OTLP Specification 1.0.0 with OTLP/gRPC and OTLP/HTTP. " + + "Provides protocol detection using the HTTP Content-Type header." +) +@WritesAttributes({ + @WritesAttribute(attribute = TelemetryAttributeName.MIME_TYPE, description = "Content-Type set to application/json"), + @WritesAttribute(attribute = TelemetryAttributeName.RESOURCE_TYPE, description = "OpenTelemetry Resource Type: LOGS, METRICS, or TRACES"), + @WritesAttribute(attribute = TelemetryAttributeName.RESOURCE_COUNT, description = "Count of resource elements included in messages"), +}) +public class ListenOTLP extends AbstractProcessor { + + static final PropertyDescriptor ADDRESS = new PropertyDescriptor.Builder() + .name("Address") + .displayName("Address") + .description("Internet Protocol Address on which to listen for OTLP Export Service Requests. The default value enables listening on all addresses.") + .required(true) + .defaultValue("0.0.0.0") + .addValidator(StandardValidators.NON_BLANK_VALIDATOR) + .expressionLanguageSupported(ExpressionLanguageScope.NONE) + .build(); + + static final PropertyDescriptor PORT = new PropertyDescriptor.Builder() + .name("Port") + .displayName("Port") + .description("TCP port number on which to listen for OTLP Export Service Requests over HTTP and gRPC") + .required(true) + .defaultValue("4317") + .addValidator(StandardValidators.PORT_VALIDATOR) + .expressionLanguageSupported(ExpressionLanguageScope.NONE) + .build(); + + static final PropertyDescriptor SSL_CONTEXT_SERVICE = new PropertyDescriptor.Builder() + .name("SSL Context Service") + .displayName("SSL Context Service") + .description("SSL Context Service enables TLS communication for HTTPS") + .required(true) + .identifiesControllerService(SSLContextService.class) + .expressionLanguageSupported(ExpressionLanguageScope.NONE) + .build(); + + static final PropertyDescriptor CLIENT_AUTHENTICATION = new PropertyDescriptor.Builder() + .name("Client Authentication") + .displayName("Client Authentication") + .description("Client authentication policy for TLS communication with HTTPS") + .required(true) + .allowableValues(ClientAuth.values()) + .defaultValue(ClientAuth.WANT.name()) + .expressionLanguageSupported(ExpressionLanguageScope.NONE) + .build(); + + static final PropertyDescriptor WORKER_THREADS = new PropertyDescriptor.Builder() + .name("Worker Threads") + .displayName("Worker Threads") + .description("Number of threads responsible for decoding and queuing incoming OTLP Export Service Requests") + .required(true) + .defaultValue("2") + .addValidator(StandardValidators.POSITIVE_INTEGER_VALIDATOR) + .expressionLanguageSupported(ExpressionLanguageScope.NONE) + .build(); + + static final PropertyDescriptor QUEUE_CAPACITY = new PropertyDescriptor.Builder() + .name("Queue Capacity") + .displayName("Queue Capacity") + .description("Maximum number of OTLP request resource elements that can be received and queued") + .required(true) + .defaultValue("10000") + .addValidator(StandardValidators.POSITIVE_INTEGER_VALIDATOR) + .expressionLanguageSupported(ExpressionLanguageScope.NONE) + .build(); + + static final PropertyDescriptor BATCH_SIZE = new PropertyDescriptor.Builder() + .name("Batch Size") + .displayName("Batch Size") + .description("Maximum number of OTLP request resource elements included in each FlowFile produced") + .required(true) + .defaultValue("1000") + .addValidator(StandardValidators.POSITIVE_INTEGER_VALIDATOR) + .expressionLanguageSupported(ExpressionLanguageScope.NONE) + .build(); + + static final Relationship SUCCESS = new Relationship.Builder() + .name("success") + .description("Export Service Requests containing OTLP Telemetry") + .build(); + + private static final Set<Relationship> RELATIONSHIPS = Collections.singleton(SUCCESS); + + private static final List<PropertyDescriptor> DESCRIPTORS = List.of( + ADDRESS, + PORT, + SSL_CONTEXT_SERVICE, + CLIENT_AUTHENTICATION, + WORKER_THREADS, + QUEUE_CAPACITY, + BATCH_SIZE + ); + + private static final String TRANSIT_URI_FORMAT = "https://%s:%d";; + + private Iterator<RequestCallback> requestCallbackProvider; + + private EventServer server; + + @Override + public final Set<Relationship> getRelationships() { + return RELATIONSHIPS; + } + + @Override + public List<PropertyDescriptor> getSupportedPropertyDescriptors() { + return DESCRIPTORS; + } + + @OnScheduled + public void onScheduled(final ProcessContext context) throws UnknownHostException { + final EventServerFactory eventServerFactory = createEventServerFactory(context); + server = eventServerFactory.getEventServer(); + } + + @OnStopped + public void onStopped() { + if (server == null) { + getLogger().info("Server not running"); Review Comment: Thanks for the note and question. Yes, it was from some early iterations, as it highlights the server status in some edge cases when using the mock TestRunner with different arguments. However, I agree that in normal operation, it should not happen, it there is nothing to do anyway, so I will simplify the logic and avoid the log. ########## nifi-nar-bundles/nifi-opentelemetry-bundle/nifi-opentelemetry-processors/src/main/java/org/apache/nifi/processors/opentelemetry/encoding/JsonServiceRequestReader.java: ########## @@ -0,0 +1,58 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.nifi.processors.opentelemetry.encoding; + +import com.google.protobuf.Message; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.nio.ByteBuffer; +import java.util.Objects; + +/** + * Service Request Reader implementation based on JSON Parser supporting standard OTLP Request Types + */ +public class JsonServiceRequestReader implements ServiceRequestReader { + private static final RequestMapper REQUEST_MAPPER = new StandardRequestMapper(); + + /** + * Read Service Request parsed from Buffer + * + * @param buffer Byte Buffer + * @param requestType Request Message Type + * @return Service Request read + */ + @Override + public <T extends Message> T read(final ByteBuffer buffer, final Class<T> requestType) { + Objects.requireNonNull(buffer, "Buffer required"); + final byte[] bytes = getBytes(buffer); + + try { + return REQUEST_MAPPER.readValue(bytes, requestType); Review Comment: Thanks for the question and recommendation! The request processing elements went through a few iterations, and this is a good opportunity for optimization. The supporting Jackson ObjectMapper supports streams, which will avoid creating the intermediate copy. ########## nifi-nar-bundles/nifi-opentelemetry-bundle/nifi-opentelemetry-processors/pom.xml: ########## @@ -0,0 +1,105 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- + Licensed to the Apache Software Foundation (ASF) under one or more + contributor license agreements. See the NOTICE file distributed with + this work for additional information regarding copyright ownership. + The ASF licenses this file to You under the Apache License, Version 2.0 + (the "License"); you may not use this file except in compliance with + the License. You may obtain a copy of the License at + http://www.apache.org/licenses/LICENSE-2.0 + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +--> +<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd";> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>org.apache.nifi</groupId> + <artifactId>nifi-opentelemetry-bundle</artifactId> + <version>2.0.0-SNAPSHOT</version> + </parent> + + <artifactId>nifi-opentelemetry-processors</artifactId> + <packaging>jar</packaging> + + <dependencies> + <dependency> + <groupId>org.apache.nifi</groupId> + <artifactId>nifi-ssl-context-service-api</artifactId> + <version>2.0.0-SNAPSHOT</version> + <scope>provided</scope> + </dependency> + <dependency> + <groupId>org.apache.nifi</groupId> + <artifactId>nifi-event-transport</artifactId> + <version>2.0.0-SNAPSHOT</version> + </dependency> + <dependency> + <groupId>org.apache.nifi</groupId> + <artifactId>nifi-utils</artifactId> + <version>2.0.0-SNAPSHOT</version> + </dependency> + <dependency> + <groupId>org.apache.nifi</groupId> + <artifactId>nifi-api</artifactId> + </dependency> + <dependency> + <groupId>io.netty</groupId> + <artifactId>netty-codec-http</artifactId> + </dependency> + <dependency> + <groupId>io.netty</groupId> + <artifactId>netty-codec-http2</artifactId> + </dependency> + <dependency> + <groupId>commons-codec</groupId> + <artifactId>commons-codec</artifactId> + </dependency> + <dependency> + <groupId>com.fasterxml.jackson.core</groupId> + <artifactId>jackson-databind</artifactId> + </dependency> + <dependency> + <groupId>com.hubspot.jackson</groupId> + <artifactId>jackson-datatype-protobuf</artifactId> + <version>0.9.14</version> + <exclusions> + <exclusion> + <groupId>com.google.protobuf</groupId> + <artifactId>protobuf-java-util</artifactId> + </exclusion> + </exclusions> + </dependency> + <dependency> + <groupId>io.opentelemetry.proto</groupId> + <artifactId>opentelemetry-proto</artifactId> + <version>1.0.0-alpha</version> Review Comment: Good question, I also wondered about this during initial implementation. The `alpha` designation applies to the Java build of the OpenTelemetry Proto classes, not to the specification itself. The [OTLP 1.0.0 specification](https://github.com/open-telemetry/opentelemetry-proto#maturity-level) indicates the maturity level of both Protobuf and JSON representations as `Stable`, but the current [opentelemetry-proto-java](https://github.com/open-telemetry/opentelemetry-proto-java/blob/main/buildSrc/src/main/kotlin/otel.publish-conventions.gradle.kts#L16) build still appends `alpha` to the version of the published JAR files. It looks like this should be corrected in the future, but in terms of field naming and serialization formatting, this version is stable. Another alternative is to include direct compilation of Java classes from the Proto definitions as part of this module build, but that does not seem necessary. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
