Bump to use otel proto v1.7.0 and update proto files

Author: sfc-gh-bnandibhatla

scripts/plugin.py

@@ -183,7 +183,7 @@ def from_descriptor(descriptor: FieldDescriptorProto, group: Optional[str] = Non
 
         if proto_type == "message" or proto_type == "enum":
             # Extract the class name of message fields, to use as python type
-            python_type = re.sub(r"^[a-zA-Z0-9_\.]+\.v1\.", "", descriptor.type_name)
+            python_type = re.sub(r"^[a-zA-Z0-9_\.]+\.v1[a-zA-Z0-9]*\.", "", descriptor.type_name)
 
         repeated = descriptor.label == FieldDescriptorProto.LABEL_REPEATED
         if repeated:

scripts/proto_codegen.sh

@@ -12,7 +12,7 @@
 #   PROTO_REPO_DIR - the path to an existing checkout of the opentelemetry-proto repo
 
 # Pinned commit/branch/tag for the current version used in opentelemetry-proto python package.
-PROTO_REPO_BRANCH_OR_COMMIT="v1.2.0"
+PROTO_REPO_BRANCH_OR_COMMIT="v1.7.0"
 
 set -e
 

src/snowflake/telemetry/_internal/opentelemetry/proto/collector/profiles/v1development/profiles_service_marshaler.py

@@ -0,0 +1,148 @@
+# Generated by the protoc compiler with a custom plugin. DO NOT EDIT!
+# sources: opentelemetry/proto/collector/profiles/v1development/profiles_service.proto
+#
+# Copyright (c) 2012-2024 Snowflake Inc. All rights reserved.
+#
+# Copyright 2023, OpenTelemetry Authors
+#
+# Licensed 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.
+#
+# This file has been generated from the original proto schema at
+#
+#     https://github.com/open-telemetry/opentelemetry-proto
+#
+# using a custom protoc compiler plugin by Snowflake Inc.
+
+from __future__ import annotations
+
+import struct
+from typing import List
+
+from snowflake.telemetry._internal.opentelemetry.proto.profiles.v1development.profiles_marshaler import *
+from snowflake.telemetry._internal.serialize import (
+    Enum,
+    MessageMarshaler,
+    Varint,
+)
+
+
+class ExportProfilesServiceRequest(MessageMarshaler):
+    @property
+    def resource_profiles(self) -> List[ResourceProfiles]:
+        if self._resource_profiles is None:
+            self._resource_profiles = list()
+        return self._resource_profiles
+
+    @property
+    def dictionary(self) -> ProfilesDictionary:
+        if self._dictionary is None:
+            self._dictionary = ProfilesDictionary()
+        return self._dictionary
+
+    def __init__(
+        self,
+        resource_profiles: List[ResourceProfiles] = None,
+        dictionary: ProfilesDictionary = None,
+    ):
+        self._resource_profiles: List[ResourceProfiles] = resource_profiles
+        self._dictionary: ProfilesDictionary = dictionary
+
+    def calculate_size(self) -> int:
+        size = 0
+        if self._resource_profiles:
+            size += sum(
+                message._get_size()
+                + len(b"\n")
+                + Varint.size_varint_u32(message._get_size())
+                for message in self._resource_profiles
+            )
+        if self._dictionary is not None:
+            size += (
+                len(b"\x12")
+                + Varint.size_varint_u32(self._dictionary._get_size())
+                + self._dictionary._get_size()
+            )
+        return size
+
+    def write_to(self, out: bytearray) -> None:
+        if self._resource_profiles:
+            for v in self._resource_profiles:
+                out += b"\n"
+                Varint.write_varint_u32(out, v._get_size())
+                v.write_to(out)
+        if self._dictionary is not None:
+            out += b"\x12"
+            Varint.write_varint_u32(out, self._dictionary._get_size())
+            self._dictionary.write_to(out)
+
+
+class ExportProfilesServiceResponse(MessageMarshaler):
+    @property
+    def partial_success(self) -> ExportProfilesPartialSuccess:
+        if self._partial_success is None:
+            self._partial_success = ExportProfilesPartialSuccess()
+        return self._partial_success
+
+    def __init__(
+        self,
+        partial_success: ExportProfilesPartialSuccess = None,
+    ):
+        self._partial_success: ExportProfilesPartialSuccess = partial_success
+
+    def calculate_size(self) -> int:
+        size = 0
+        if self._partial_success is not None:
+            size += (
+                len(b"\n")
+                + Varint.size_varint_u32(self._partial_success._get_size())
+                + self._partial_success._get_size()
+            )
+        return size
+
+    def write_to(self, out: bytearray) -> None:
+        if self._partial_success is not None:
+            out += b"\n"
+            Varint.write_varint_u32(out, self._partial_success._get_size())
+            self._partial_success.write_to(out)
+
+
+class ExportProfilesPartialSuccess(MessageMarshaler):
+    rejected_profiles: int
+    error_message: str
+
+    def __init__(
+        self,
+        rejected_profiles: int = 0,
+        error_message: str = "",
+    ):
+        self.rejected_profiles: int = rejected_profiles
+        self.error_message: str = error_message
+
+    def calculate_size(self) -> int:
+        size = 0
+        if self.rejected_profiles:
+            size += len(b"\x08") + Varint.size_varint_i64(self.rejected_profiles)
+        if self.error_message:
+            v = self.error_message.encode("utf-8")
+            size += len(b"\x12") + Varint.size_varint_u32(len(v)) + len(v)
+        return size
+
+    def write_to(self, out: bytearray) -> None:
+        if self.rejected_profiles:
+            out += b"\x08"
+            Varint.write_varint_i64(out, self.rejected_profiles)
+        if self.error_message:
+            v = self.error_message.encode("utf-8")
+            out += b"\x12"
+            Varint.write_varint_u32(out, len(v))
+            out += v

src/snowflake/telemetry/_internal/opentelemetry/proto/common/v1/common_marshaler.py

@@ -301,3 +301,86 @@ def write_to(self, out: bytearray) -> None:
         if self.dropped_attributes_count:
             out += b" "
             Varint.write_varint_u32(out, self.dropped_attributes_count)
+
+
+class EntityRef(MessageMarshaler):
+    schema_url: str
+    type: str
+
+    @property
+    def id_keys(self) -> List[str]:
+        if self._id_keys is None:
+            self._id_keys = list()
+        return self._id_keys
+
+    @property
+    def description_keys(self) -> List[str]:
+        if self._description_keys is None:
+            self._description_keys = list()
+        return self._description_keys
+
+    def __init__(
+        self,
+        schema_url: str = "",
+        type: str = "",
+        id_keys: List[str] = None,
+        description_keys: List[str] = None,
+    ):
+        self.schema_url: str = schema_url
+        self.type: str = type
+        self._id_keys: List[str] = id_keys
+        self._description_keys: List[str] = description_keys
+
+    def calculate_size(self) -> int:
+        size = 0
+        if self.schema_url:
+            v = self.schema_url.encode("utf-8")
+            size += len(b"\n") + Varint.size_varint_u32(len(v)) + len(v)
+        if self.type:
+            v = self.type.encode("utf-8")
+            size += len(b"\x12") + Varint.size_varint_u32(len(v)) + len(v)
+        if self._id_keys:
+            size = 0
+            for s in self._id_keys:
+                string_data = s.encode("utf-8")
+                size += (
+                    len(b"\x1a")
+                    + Varint.size_varint_u32(len(string_data))
+                    + len(string_data)
+                )
+            size += size
+        if self._description_keys:
+            size = 0
+            for s in self._description_keys:
+                string_data = s.encode("utf-8")
+                size += (
+                    len(b'"')
+                    + Varint.size_varint_u32(len(string_data))
+                    + len(string_data)
+                )
+            size += size
+        return size
+
+    def write_to(self, out: bytearray) -> None:
+        if self.schema_url:
+            v = self.schema_url.encode("utf-8")
+            out += b"\n"
+            Varint.write_varint_u32(out, len(v))
+            out += v
+        if self.type:
+            v = self.type.encode("utf-8")
+            out += b"\x12"
+            Varint.write_varint_u32(out, len(v))
+            out += v
+        if self._id_keys:
+            for v in self._id_keys:
+                out += b"\x1a"
+                data = v.encode("utf-8")
+                Varint.write_varint_u32(out, len(data))
+                out += data
+        if self._description_keys:
+            for v in self._description_keys:
+                out += b'"'
+                data = v.encode("utf-8")
+                Varint.write_varint_u32(out, len(data))
+                out += data

src/snowflake/telemetry/_internal/opentelemetry/proto/logs/v1/logs_marshaler.py

@@ -248,6 +248,7 @@ def attributes(self) -> List[KeyValue]:
     trace_id: bytes
     span_id: bytes
     observed_time_unix_nano: int
+    event_name: str
 
     def __init__(
         self,
@@ -261,6 +262,7 @@ def __init__(
         trace_id: bytes = b"",
         span_id: bytes = b"",
         observed_time_unix_nano: int = 0,
+        event_name: str = "",
     ):
         self.time_unix_nano: int = time_unix_nano
         self.severity_number: SeverityNumber = severity_number
@@ -272,6 +274,7 @@ def __init__(
         self.trace_id: bytes = trace_id
         self.span_id: bytes = span_id
         self.observed_time_unix_nano: int = observed_time_unix_nano
+        self.event_name: str = event_name
 
     def calculate_size(self) -> int:
         size = 0
@@ -316,6 +319,9 @@ def calculate_size(self) -> int:
             )
         if self.observed_time_unix_nano:
             size += len(b"Y") + 8
+        if self.event_name:
+            v = self.event_name.encode("utf-8")
+            size += len(b"b") + Varint.size_varint_u32(len(v)) + len(v)
         return size
 
     def write_to(self, out: bytearray) -> None:
@@ -359,3 +365,8 @@ def write_to(self, out: bytearray) -> None:
         if self.observed_time_unix_nano:
             out += b"Y"
             out += struct.pack("<Q", self.observed_time_unix_nano)
+        if self.event_name:
+            v = self.event_name.encode("utf-8")
+            out += b"b"
+            Varint.write_varint_u32(out, len(v))
+            out += v