From e15141a1fd920da2eb02e9f5f634dcd43592dc8c Mon Sep 17 00:00:00 2001
From: Chris Henzie <chrishenzie@gmail.com>
Date: Tue, 10 Mar 2026 17:14:44 -0700
Subject: [PATCH 1/6] Move cgroup namespace placement higher in spec builder

Moves cgroup namespace addition logic higher in buildLinuxSpec so it
runs before any custom spec adjusters (such as WithMounts).

This is necessary because subsequent spec adjusters may want to inspect
the set of namespaces to make decisions (e.g., configuring mount options
based on whether or not they are shared with the host).

Signed-off-by: Chris Henzie <chrishenzie@gmail.com>
---
 internal/cri/server/container_create.go       | 16 +++----
 .../cri/server/container_create_linux_test.go | 46 +++++++++++++++++++
 2 files changed, 54 insertions(+), 8 deletions(-)

diff --git a/internal/cri/server/container_create.go b/internal/cri/server/container_create.go
index 7ddb1b3937235..43e612a0731a7 100644
--- a/internal/cri/server/container_create.go
+++ b/internal/cri/server/container_create.go
@@ -792,6 +792,14 @@ func (c *criService) buildLinuxSpec(
 		}
 	}()
 
+	// cgroupns is used for hiding /sys/fs/cgroup from containers.
+	// For compatibility, cgroupns is not used when running in cgroup v1 mode or in privileged.
+	// https://github.com/containers/libpod/issues/4363
+	// https://github.com/kubernetes/enhancements/blob/0e409b47497e398b369c281074485c8de129694f/keps/sig-node/20191118-cgroups-v2.md#cgroup-namespace
+	if isUnifiedCgroupsMode() && !securityContext.GetPrivileged() {
+		specOpts = append(specOpts, oci.WithLinuxNamespace(runtimespec.LinuxNamespace{Type: runtimespec.CgroupNamespace}))
+	}
+
 	var ociSpecOpts oci.SpecOpts
 	if ociRuntime.CgroupWritable {
 		ociSpecOpts = customopts.WithMountsCgroupWritable(c.os, config, extraMounts, mountLabel, runtimeHandler)
@@ -930,14 +938,6 @@ func (c *criService) buildLinuxSpec(
 		annotations.DefaultCRIAnnotations(sandboxID, containerName, imageName, sandboxConfig, false)...,
 	)
 
-	// cgroupns is used for hiding /sys/fs/cgroup from containers.
-	// For compatibility, cgroupns is not used when running in cgroup v1 mode or in privileged.
-	// https://github.com/containers/libpod/issues/4363
-	// https://github.com/kubernetes/enhancements/blob/0e409b47497e398b369c281074485c8de129694f/keps/sig-node/20191118-cgroups-v2.md#cgroup-namespace
-	if isUnifiedCgroupsMode() && !securityContext.GetPrivileged() {
-		specOpts = append(specOpts, oci.WithLinuxNamespace(runtimespec.LinuxNamespace{Type: runtimespec.CgroupNamespace}))
-	}
-
 	return specOpts, nil
 }
 
diff --git a/internal/cri/server/container_create_linux_test.go b/internal/cri/server/container_create_linux_test.go
index 0242c0e83d5b0..a37a849aa3193 100644
--- a/internal/cri/server/container_create_linux_test.go
+++ b/internal/cri/server/container_create_linux_test.go
@@ -487,6 +487,52 @@ func TestPrivilegedBindMount(t *testing.T) {
 	}
 }
 
+func TestCgroupNamespace(t *testing.T) {
+	testPid := uint32(1234)
+	c := newTestCRIService()
+	testSandboxID := "sandbox-id"
+	testContainerName := "container-name"
+	containerConfig, sandboxConfig, imageConfig, _ := getCreateContainerTestData()
+	ociRuntime := config.Runtime{}
+
+	tests := []struct {
+		desc                  string
+		privileged            bool
+		expectCgroupNamespace bool
+	}{
+		{
+			desc:                  "non-privileged container should get cgroup namespace",
+			privileged:            false,
+			expectCgroupNamespace: true,
+		},
+		{
+			desc:                  "privileged container should not get cgroup namespace",
+			privileged:            true,
+			expectCgroupNamespace: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.desc, func(t *testing.T) {
+			containerConfig.Linux.SecurityContext.Privileged = tt.privileged
+			sandboxConfig.Linux.SecurityContext.Privileged = tt.privileged
+
+			spec, err := c.buildContainerSpec(currentPlatform, t.Name(), testSandboxID, testPid, "", testContainerName, testImageName, containerConfig, sandboxConfig, imageConfig, nil, ociRuntime, nil)
+			assert.NoError(t, err)
+
+			hasCgroupNS := false
+			for _, ns := range spec.Linux.Namespaces {
+				if ns.Type == runtimespec.CgroupNamespace {
+					hasCgroupNS = true
+					break
+				}
+			}
+
+			assert.Equal(t, tt.expectCgroupNamespace, hasCgroupNS)
+		})
+	}
+}
+
 func TestMountPropagation(t *testing.T) {
 
 	sharedLookupMountFn := func(string) (mount.Info, error) {

From f84ddfa4fbb9741633bf722ceea943ded2205b15 Mon Sep 17 00:00:00 2001
From: Chris Henzie <chrishenzie@gmail.com>
Date: Tue, 10 Mar 2026 17:14:46 -0700
Subject: [PATCH 2/6] Preserve host cgroup mount options for privileged
 containers

Privileged containers don't have a cgroup namespace and share the host's
cgroup namespace. Mounting cgroup2 inside these containers can
inadvertently alter the host's cgroup2 VFS superblock mount options
because they are shared.

To prevent this, update WithMounts to read the host's /sys/fs/cgroup
mount options and explicitly propagate nsdelegate and
memory_recursiveprot into the container's mount spec. This avoids
stripping them on the host when they are not in the hardcoded default
set.

Signed-off-by: Chris Henzie <chrishenzie@gmail.com>
---
 internal/cri/opts/spec_linux_opts.go | 27 +++++++++-
 internal/cri/opts/spec_linux_test.go | 75 ++++++++++++++++++++++++++++
 2 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/internal/cri/opts/spec_linux_opts.go b/internal/cri/opts/spec_linux_opts.go
index 348e699496def..1818352736189 100644
--- a/internal/cri/opts/spec_linux_opts.go
+++ b/internal/cri/opts/spec_linux_opts.go
@@ -22,6 +22,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -70,11 +71,35 @@ func withMounts(osi osinterface.OS, config *runtime.ContainerConfig, extra []*ru
 		if cgroupWritable {
 			mode = "rw"
 		}
+
+		cgroupOptions := []string{"nosuid", "noexec", "nodev", "relatime", mode}
+
+		hasCgroupNS := false
+		if s.Linux != nil {
+			hasCgroupNS = slices.ContainsFunc(s.Linux.Namespaces, func(ns runtimespec.LinuxNamespace) bool {
+				return ns.Type == runtimespec.CgroupNamespace
+			})
+		}
+
+		// If a container shares the host's cgroup namespace, mounting cgroup2
+		// inside the container applies the new mount options to the single shared
+		// cgroup2 VFS superblock. Therefore, explicitly copy these options from
+		// the host's /sys/fs/cgroup to avoid being stripped.
+		if !hasCgroupNS {
+			if mountInfo, err := osi.LookupMount("/sys/fs/cgroup"); err == nil {
+				for opt := range strings.SplitSeq(mountInfo.VFSOptions, ",") {
+					if opt == "nsdelegate" || opt == "memory_recursiveprot" {
+						cgroupOptions = append(cgroupOptions, opt)
+					}
+				}
+			}
+		}
+
 		s.Mounts = append(s.Mounts, runtimespec.Mount{
 			Source:      "cgroup",
 			Destination: "/sys/fs/cgroup",
 			Type:        "cgroup",
-			Options:     []string{"nosuid", "noexec", "nodev", "relatime", mode},
+			Options:     cgroupOptions,
 		})
 
 		// Copy all mounts from default mounts, except for
diff --git a/internal/cri/opts/spec_linux_test.go b/internal/cri/opts/spec_linux_test.go
index 1c9942f80cc34..2d729d1bb8058 100644
--- a/internal/cri/opts/spec_linux_test.go
+++ b/internal/cri/opts/spec_linux_test.go
@@ -17,10 +17,15 @@
 package opts
 
 import (
+	"context"
 	"testing"
 
+	"github.com/containerd/containerd/v2/core/mount"
+	ostesting "github.com/containerd/containerd/v2/pkg/os/testing"
+	runtimespec "github.com/opencontainers/runtime-spec/specs-go"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	runtime "k8s.io/cri-api/pkg/apis/runtime/v1"
 )
 
 func TestMergeGids(t *testing.T) {
@@ -45,3 +50,73 @@ func TestRestrictOOMScoreAdj(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, got, current+1)
 }
+
+func TestWithMountsCgroupNamespaceOptions(t *testing.T) {
+	tests := []struct {
+		name          string
+		hasCgroupNS   bool
+		hostMountOpts string
+		expectedOpts  []string
+	}{
+		{
+			name:          "has cgroupns, should use default options",
+			hasCgroupNS:   true,
+			hostMountOpts: "rw,nosuid,nodev,noexec,relatime,nsdelegate,memory_recursiveprot",
+			expectedOpts:  []string{"nosuid", "noexec", "nodev", "relatime", "ro"},
+		},
+		{
+			name:          "no cgroupns, with host options present",
+			hasCgroupNS:   false,
+			hostMountOpts: "rw,nosuid,nodev,noexec,relatime,nsdelegate,memory_recursiveprot",
+			expectedOpts:  []string{"nosuid", "noexec", "nodev", "relatime", "ro", "nsdelegate", "memory_recursiveprot"},
+		},
+		{
+			name:          "no cgroupns, with host missing nsdelegate",
+			hasCgroupNS:   false,
+			hostMountOpts: "rw,nosuid,nodev,noexec,relatime,memory_recursiveprot",
+			expectedOpts:  []string{"nosuid", "noexec", "nodev", "relatime", "ro", "memory_recursiveprot"},
+		},
+		{
+			name:          "no cgroupns, with host missing all extra options",
+			hasCgroupNS:   false,
+			hostMountOpts: "rw,nosuid,nodev,noexec,relatime",
+			expectedOpts:  []string{"nosuid", "noexec", "nodev", "relatime", "ro"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fakeOS := ostesting.NewFakeOS()
+			fakeOS.LookupMountFn = func(path string) (mount.Info, error) {
+				if path == "/sys/fs/cgroup" {
+					return mount.Info{VFSOptions: tt.hostMountOpts}, nil
+				}
+				return mount.Info{}, nil
+			}
+
+			config := &runtime.ContainerConfig{
+				Linux: &runtime.LinuxContainerConfig{},
+			}
+
+			spec := &runtimespec.Spec{}
+			if tt.hasCgroupNS {
+				spec.Linux = &runtimespec.Linux{Namespaces: []runtimespec.LinuxNamespace{{Type: runtimespec.CgroupNamespace}}}
+			}
+
+			opt := withMounts(fakeOS, config, nil, "", nil, false)
+			err := opt(context.Background(), nil, nil, spec)
+			require.NoError(t, err)
+
+			var cgroupMount *runtimespec.Mount
+			for _, m := range spec.Mounts {
+				if m.Destination == "/sys/fs/cgroup" {
+					cgroupMount = &m
+					break
+				}
+			}
+
+			require.NotNil(t, cgroupMount)
+			assert.ElementsMatch(t, tt.expectedOpts, cgroupMount.Options)
+		})
+	}
+}

From d2f67d399022ed170f0fa836c01b47c72f434c35 Mon Sep 17 00:00:00 2001
From: Chris Henzie <chrishenzie@gmail.com>
Date: Tue, 10 Mar 2026 17:14:48 -0700
Subject: [PATCH 3/6] Forward RUNC_FLAVOR env var down to integration tests

Update Vagrantfile and cri-integration test runner to forward
RUNC_FLAVOR to the test environment.

Allows integration tests to conditionally skip testing certain cgroup
mount setups when running against other runtimes that may not support
them yet.

Signed-off-by: Chris Henzie <chrishenzie@gmail.com>
---
 Vagrantfile                    | 2 ++
 script/test/cri-integration.sh | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/Vagrantfile b/Vagrantfile
index d251c1c1cc26e..16acaf08fb8b8 100644
--- a/Vagrantfile
+++ b/Vagrantfile
@@ -278,6 +278,7 @@ EOF
         'GOTESTSUM_JSONFILE': ENV['GOTESTSUM_JSONFILE'],
         'GITHUB_WORKSPACE': '',
         'CGROUP_DRIVER': ENV['CGROUP_DRIVER'],
+        'RUNC_FLAVOR': ENV['RUNC_FLAVOR'] || "runc",
     }
     sh.inline = <<~SHELL
         #!/usr/bin/env bash
@@ -306,6 +307,7 @@ EOF
         'GOTEST': ENV['GOTEST'] || "go test",
         'REPORT_DIR': ENV['REPORT_DIR'],
         'CGROUP_DRIVER': ENV['CGROUP_DRIVER'],
+        'RUNC_FLAVOR': ENV['RUNC_FLAVOR'] || "runc",
     }
     sh.inline = <<~SHELL
         #!/usr/bin/env bash
diff --git a/script/test/cri-integration.sh b/script/test/cri-integration.sh
index 1ac35bad1cd6a..fd696430ae2d8 100755
--- a/script/test/cri-integration.sh
+++ b/script/test/cri-integration.sh
@@ -46,6 +46,10 @@ CMD=""
 if [ -n "${sudo}" ]; then
   CMD+="${sudo} "
 fi
+CMD+="env "
+if [ -n "${RUNC_FLAVOR:-}" ]; then
+  CMD+="RUNC_FLAVOR=${RUNC_FLAVOR} "
+fi
 CMD+="${PWD}/bin/cri-integration.test"
 
 ${CMD} --test.run="${FOCUS}" --test.v \

From 0eef29a1a92474f9dfb9c21e70790b25221cabdc Mon Sep 17 00:00:00 2001
From: Chris Henzie <chrishenzie@gmail.com>
Date: Tue, 10 Mar 2026 17:14:49 -0700
Subject: [PATCH 4/6] Add integration test for privileged container cgroup
 mounts

Verifies that running a privileged container does not alter host cgroup
mount options (specifically nsdelegate and memory_recursiveprot).

Creates a privileged sandbox and container, starts it, and compares the
host's /sys/fs/cgroup mount options before and after execution to
guarantee safety.

Signed-off-by: Chris Henzie <chrishenzie@gmail.com>
---
 ...ntainer_cgroup_mount_options_linux_test.go | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 integration/container_cgroup_mount_options_linux_test.go

diff --git a/integration/container_cgroup_mount_options_linux_test.go b/integration/container_cgroup_mount_options_linux_test.go
new file mode 100644
index 0000000000000..9de39eb4a6aeb
--- /dev/null
+++ b/integration/container_cgroup_mount_options_linux_test.go
@@ -0,0 +1,79 @@
+/*
+   Copyright The containerd 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.
+*/
+
+package integration
+
+import (
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/containerd/cgroups/v3"
+	"github.com/containerd/containerd/v2/core/mount"
+	"github.com/containerd/containerd/v2/integration/images"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPrivilegedContainerCgroupMountOptions(t *testing.T) {
+	if f := os.Getenv("RUNC_FLAVOR"); f == "crun" {
+		t.Skip("Skipping until crun supports cgroup v2 mount options (https://github.com/containers/crun/pull/2040)")
+	}
+	if cgroups.Mode() != cgroups.Unified {
+		t.Skip("Requires cgroup v2")
+	}
+
+	hostMountBefore, err := mount.Lookup("/sys/fs/cgroup")
+	require.NoError(t, err)
+
+	if !strings.Contains(hostMountBefore.VFSOptions, "nsdelegate") && !strings.Contains(hostMountBefore.VFSOptions, "memory_recursiveprot") {
+		t.Skip("requires host cgroup mount to have nsdelegate or memory_recursiveprot")
+	}
+
+	testImage := images.Get(images.BusyBox)
+	EnsureImageExists(t, testImage)
+
+	t.Log("Create a sandbox with privileged=true")
+	sb, sbConfig := PodSandboxConfigWithCleanup(t, "sandbox", "privileged-cgroup-mount-test", WithPodSecurityContext(true))
+
+	t.Log("Create a container with privileged=true")
+	cnConfig := ContainerConfig("container", testImage, WithCommand("sh", "-c", "sleep 1d"), WithSecurityContext(true))
+	cn, err := runtimeService.CreateContainer(sb, cnConfig, sbConfig)
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		if err := runtimeService.RemoveContainer(cn); err != nil {
+			t.Logf("failed to remove container %s: %v", cn, err)
+		}
+	})
+
+	t.Log("Start the container")
+	require.NoError(t, runtimeService.StartContainer(cn))
+	t.Cleanup(func() {
+		if err := runtimeService.StopContainer(cn, 10); err != nil {
+			t.Logf("failed to stop container %s: %v", cn, err)
+		}
+	})
+
+	hostMountAfter, err := mount.Lookup("/sys/fs/cgroup")
+	require.NoError(t, err)
+
+	if strings.Contains(hostMountBefore.VFSOptions, "nsdelegate") {
+		assert.Contains(t, hostMountAfter.VFSOptions, "nsdelegate", "nsdelegate should be preserved on the host cgroup mount")
+	}
+	if strings.Contains(hostMountBefore.VFSOptions, "memory_recursiveprot") {
+		assert.Contains(t, hostMountAfter.VFSOptions, "memory_recursiveprot", "memory_recursiveprot should be preserved on the host cgroup mount")
+	}
+}

From 46bd9a75cd93612396f496018379d70a95d2ccbc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Mar 2026 23:24:06 +0000
Subject: [PATCH 5/6] build(deps): bump the k8s group with 3 updates

Bumps the k8s group with 3 updates: [k8s.io/apimachinery](https://github.com/kubernetes/apimachinery), [k8s.io/client-go](https://github.com/kubernetes/client-go) and [k8s.io/cri-api](https://github.com/kubernetes/cri-api).


Updates `k8s.io/apimachinery` from 0.35.2 to 0.35.3
- [Commits](https://github.com/kubernetes/apimachinery/compare/v0.35.2...v0.35.3)

Updates `k8s.io/client-go` from 0.35.2 to 0.35.3
- [Changelog](https://github.com/kubernetes/client-go/blob/master/CHANGELOG.md)
- [Commits](https://github.com/kubernetes/client-go/compare/v0.35.2...v0.35.3)

Updates `k8s.io/cri-api` from 0.35.2 to 0.35.3
- [Commits](https://github.com/kubernetes/cri-api/compare/v0.35.2...v0.35.3)

---
updated-dependencies:
- dependency-name: k8s.io/apimachinery
  dependency-version: 0.35.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s
- dependency-name: k8s.io/client-go
  dependency-version: 0.35.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s
- dependency-name: k8s.io/cri-api
  dependency-version: 0.35.3
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: k8s
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 go.mod             |  8 ++++----
 go.sum             | 16 ++++++++--------
 vendor/modules.txt |  8 ++++----
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/go.mod b/go.mod
index a01a76bc41eaa..b376635945f42 100644
--- a/go.mod
+++ b/go.mod
@@ -83,9 +83,9 @@ require (
 	google.golang.org/grpc v1.79.3
 	google.golang.org/protobuf v1.36.11
 	gopkg.in/inf.v0 v0.9.1
-	k8s.io/apimachinery v0.35.2
-	k8s.io/client-go v0.35.2
-	k8s.io/cri-api v0.35.2
+	k8s.io/apimachinery v0.35.3
+	k8s.io/client-go v0.35.3
+	k8s.io/cri-api v0.35.3
 	k8s.io/klog/v2 v2.140.0
 	tags.cncf.io/container-device-interface v1.1.0
 )
@@ -152,7 +152,7 @@ require (
 	golang.org/x/text v0.34.0 // indirect
 	google.golang.org/genproto/googleapis/api v0.0.0-20260209200024-4cfbd4190f57 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	k8s.io/api v0.35.2 // indirect
+	k8s.io/api v0.35.3 // indirect
 	k8s.io/kube-openapi v0.0.0-20250910181357-589584f1c912 // indirect
 	k8s.io/utils v0.0.0-20251002143259-bc988d571ff4 // indirect
 	sigs.k8s.io/json v0.0.0-20250730193827-2d320260d730 // indirect
diff --git a/go.sum b/go.sum
index 4babe8f9eb83b..4848c08882ff0 100644
--- a/go.sum
+++ b/go.sum
@@ -559,14 +559,14 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
-k8s.io/api v0.35.2 h1:tW7mWc2RpxW7HS4CoRXhtYHSzme1PN1UjGHJ1bdrtdw=
-k8s.io/api v0.35.2/go.mod h1:7AJfqGoAZcwSFhOjcGM7WV05QxMMgUaChNfLTXDRE60=
-k8s.io/apimachinery v0.35.2 h1:NqsM/mmZA7sHW02JZ9RTtk3wInRgbVxL8MPfzSANAK8=
-k8s.io/apimachinery v0.35.2/go.mod h1:jQCgFZFR1F4Ik7hvr2g84RTJSZegBc8yHgFWKn//hns=
-k8s.io/client-go v0.35.2 h1:YUfPefdGJA4aljDdayAXkc98DnPkIetMl4PrKX97W9o=
-k8s.io/client-go v0.35.2/go.mod h1:4QqEwh4oQpeK8AaefZ0jwTFJw/9kIjdQi0jpKeYvz7g=
-k8s.io/cri-api v0.35.2 h1:Lfg8KG0XFPph2KM+yWA+/mfv71v7UOkGt+uuqKMSWCU=
-k8s.io/cri-api v0.35.2/go.mod h1:Cnt29u/tYl1Se1cBRL30uSZ/oJ5TaIp4sZm1xDLvcMc=
+k8s.io/api v0.35.3 h1:pA2fiBc6+N9PDf7SAiluKGEBuScsTzd2uYBkA5RzNWQ=
+k8s.io/api v0.35.3/go.mod h1:9Y9tkBcFwKNq2sxwZTQh1Njh9qHl81D0As56tu42GA4=
+k8s.io/apimachinery v0.35.3 h1:MeaUwQCV3tjKP4bcwWGgZ/cp/vpsRnQzqO6J6tJyoF8=
+k8s.io/apimachinery v0.35.3/go.mod h1:jQCgFZFR1F4Ik7hvr2g84RTJSZegBc8yHgFWKn//hns=
+k8s.io/client-go v0.35.3 h1:s1lZbpN4uI6IxeTM2cpdtrwHcSOBML1ODNTCCfsP1pg=
+k8s.io/client-go v0.35.3/go.mod h1:RzoXkc0mzpWIDvBrRnD+VlfXP+lRzqQjCmKtiwZ8Q9c=
+k8s.io/cri-api v0.35.3 h1:gONTLBvK1eBPyveXEQ39mtTqi2oANeHj1mCo1YhQosI=
+k8s.io/cri-api v0.35.3/go.mod h1:Cnt29u/tYl1Se1cBRL30uSZ/oJ5TaIp4sZm1xDLvcMc=
 k8s.io/klog/v2 v2.140.0 h1:Tf+J3AH7xnUzZyVVXhTgGhEKnFqye14aadWv7bzXdzc=
 k8s.io/klog/v2 v2.140.0/go.mod h1:o+/RWfJ6PwpnFn7OyAG3QnO47BFsymfEfrz6XyYSSp0=
 k8s.io/kube-openapi v0.0.0-20250910181357-589584f1c912 h1:Y3gxNAuB0OBLImH611+UDZcmKS3g6CthxToOb37KgwE=
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 5e9eeae8c5150..b6ec7b6ff09bd 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -864,10 +864,10 @@ gopkg.in/inf.v0
 # gopkg.in/yaml.v3 v3.0.1
 ## explicit
 gopkg.in/yaml.v3
-# k8s.io/api v0.35.2
+# k8s.io/api v0.35.3
 ## explicit; go 1.25.0
 k8s.io/api/core/v1
-# k8s.io/apimachinery v0.35.2
+# k8s.io/apimachinery v0.35.3
 ## explicit; go 1.25.0
 k8s.io/apimachinery/pkg/api/errors
 k8s.io/apimachinery/pkg/api/meta
@@ -918,7 +918,7 @@ k8s.io/apimachinery/pkg/version
 k8s.io/apimachinery/pkg/watch
 k8s.io/apimachinery/third_party/forked/golang/netutil
 k8s.io/apimachinery/third_party/forked/golang/reflect
-# k8s.io/client-go v0.35.2
+# k8s.io/client-go v0.35.3
 ## explicit; go 1.25.0
 k8s.io/client-go/features
 k8s.io/client-go/pkg/apis/clientauthentication
@@ -941,7 +941,7 @@ k8s.io/client-go/util/exec
 k8s.io/client-go/util/flowcontrol
 k8s.io/client-go/util/keyutil
 k8s.io/client-go/util/workqueue
-# k8s.io/cri-api v0.35.2
+# k8s.io/cri-api v0.35.3
 ## explicit; go 1.25.0
 k8s.io/cri-api/pkg/apis/runtime/v1
 k8s.io/cri-api/pkg/errors

From ca88ae583c71616b96ae8ff4523e161a65e3b961 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Mar 2026 23:24:28 +0000
Subject: [PATCH 6/6] build(deps): bump the otel group across 1 directory with
 5 updates

Bumps the otel group with 5 updates in the / directory:

| Package | From | To |
| --- | --- | --- |
| [go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc](https://github.com/open-telemetry/opentelemetry-go-contrib) | `0.64.0` | `0.67.0` |
| [go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp](https://github.com/open-telemetry/opentelemetry-go-contrib) | `0.64.0` | `0.67.0` |
| [go.opentelemetry.io/otel/exporters/otlp/otlptrace](https://github.com/open-telemetry/opentelemetry-go) | `1.39.0` | `1.42.0` |
| [go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc](https://github.com/open-telemetry/opentelemetry-go) | `1.39.0` | `1.42.0` |
| [go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp](https://github.com/open-telemetry/opentelemetry-go) | `1.39.0` | `1.42.0` |



Updates `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc` from 0.64.0 to 0.67.0
- [Release notes](https://github.com/open-telemetry/opentelemetry-go-contrib/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-go-contrib/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-go-contrib/compare/zpages/v0.64.0...zpages/v0.67.0)

Updates `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp` from 0.64.0 to 0.67.0
- [Release notes](https://github.com/open-telemetry/opentelemetry-go-contrib/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-go-contrib/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-go-contrib/compare/zpages/v0.64.0...zpages/v0.67.0)

Updates `go.opentelemetry.io/otel/exporters/otlp/otlptrace` from 1.39.0 to 1.42.0
- [Release notes](https://github.com/open-telemetry/opentelemetry-go/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-go/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-go/compare/v1.39.0...v1.42.0)

Updates `go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc` from 1.39.0 to 1.42.0
- [Release notes](https://github.com/open-telemetry/opentelemetry-go/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-go/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-go/compare/v1.39.0...v1.42.0)

Updates `go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp` from 1.39.0 to 1.42.0
- [Release notes](https://github.com/open-telemetry/opentelemetry-go/releases)
- [Changelog](https://github.com/open-telemetry/opentelemetry-go/blob/main/CHANGELOG.md)
- [Commits](https://github.com/open-telemetry/opentelemetry-go/compare/v1.39.0...v1.42.0)

---
updated-dependencies:
- dependency-name: go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc
  dependency-version: 0.67.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: otel
- dependency-name: go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp
  dependency-version: 0.67.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: otel
- dependency-name: go.opentelemetry.io/otel/exporters/otlp/otlptrace
  dependency-version: 1.42.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: otel
- dependency-name: go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
  dependency-version: 1.42.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: otel
- dependency-name: go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp
  dependency-version: 1.42.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: otel
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 go.mod                                        |   12 +-
 go.sum                                        |   24 +-
 .../google.golang.org/grpc/otelgrpc/config.go |   50 +-
 .../grpc/otelgrpc/interceptor.go              |    2 +-
 .../grpc/otelgrpc/internal/parse.go           |   18 +-
 .../grpc/otelgrpc/stats_handler.go            |  215 +-
 .../grpc/otelgrpc/version.go                  |    5 +-
 .../net/http/otelhttp/client.go               |   65 -
 .../net/http/otelhttp/common.go               |    2 +-
 .../net/http/otelhttp/config.go               |   17 +-
 .../net/http/otelhttp/handler.go              |   44 +-
 .../internal/request/resp_writer_wrapper.go   |    9 +-
 .../http/otelhttp/internal/semconv/client.go  |   68 +-
 .../http/otelhttp/internal/semconv/server.go  |   29 +-
 .../http/otelhttp/internal/semconv/util.go    |    8 +-
 .../net/http/otelhttp/transport.go            |   93 +-
 .../net/http/otelhttp/version.go              |    5 +-
 .../otlp/otlptrace/otlptracegrpc/client.go    |    4 +-
 .../internal/observ/instrumentation.go        |   43 +-
 .../otlptracegrpc/internal/version.go         |    2 +-
 .../otlp/otlptrace/otlptracehttp/client.go    |   16 +
 .../internal/observ/instrumentation.go        |   36 +-
 .../otlptracehttp/internal/version.go         |    2 +-
 .../otel/exporters/otlp/otlptrace/version.go  |    2 +-
 .../otel/semconv/v1.37.0/otelconv/metric.go   | 2264 -----------------
 .../otel/semconv/v1.37.0/rpcconv/metric.go    | 1010 --------
 .../{v1.37.0 => v1.40.0}/httpconv/metric.go   |   91 +-
 .../otel/semconv/v1.40.0/rpcconv/metric.go    |  360 +++
 vendor/modules.txt                            |   29 +-
 29 files changed, 778 insertions(+), 3747 deletions(-)
 delete mode 100644 vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/client.go
 delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/otelconv/metric.go
 delete mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.37.0/rpcconv/metric.go
 rename vendor/go.opentelemetry.io/otel/semconv/{v1.37.0 => v1.40.0}/httpconv/metric.go (94%)
 create mode 100644 vendor/go.opentelemetry.io/otel/semconv/v1.40.0/rpcconv/metric.go

diff --git a/go.mod b/go.mod
index a01a76bc41eaa..281100a1ad2f4 100644
--- a/go.mod
+++ b/go.mod
@@ -66,12 +66,12 @@ require (
 	github.com/vishvananda/netlink v1.3.1
 	github.com/vishvananda/netns v0.0.5
 	go.etcd.io/bbolt v1.4.3
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.64.0
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.64.0
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0
 	go.opentelemetry.io/otel v1.42.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.39.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.39.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.39.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.42.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.42.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.42.0
 	go.opentelemetry.io/otel/sdk v1.42.0
 	go.opentelemetry.io/otel/trace v1.42.0
 	go.uber.org/goleak v1.3.0
@@ -79,7 +79,7 @@ require (
 	golang.org/x/sync v0.20.0
 	golang.org/x/sys v0.42.0
 	golang.org/x/time v0.15.0
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171
 	google.golang.org/grpc v1.79.3
 	google.golang.org/protobuf v1.36.11
 	gopkg.in/inf.v0 v0.9.1
diff --git a/go.sum b/go.sum
index 4babe8f9eb83b..633a28bf08817 100644
--- a/go.sum
+++ b/go.sum
@@ -360,18 +360,18 @@ go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0=
 go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo=
 go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
 go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.64.0 h1:RN3ifU8y4prNWeEnQp2kRRHz8UwonAEYZl8tUzHEXAk=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.64.0/go.mod h1:habDz3tEWiFANTo6oUE99EmaFUrCNYAAg3wiVmusm70=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.64.0 h1:ssfIgGNANqpVFCndZvcuyKbl0g+UAVcbBcqGkG28H0Y=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.64.0/go.mod h1:GQ/474YrbE4Jx8gZ4q5I4hrhUzM6UPzyrqJYV2AqPoQ=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0 h1:yI1/OhfEPy7J9eoa6Sj051C7n5dvpj0QX8g4sRchg04=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0/go.mod h1:NoUCKYWK+3ecatC4HjkRktREheMeEtrXoQxrqYFeHSc=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0 h1:OyrsyzuttWTSur2qN/Lm0m2a8yqyIjUVBZcxFPuXq2o=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0/go.mod h1:C2NGBr+kAB4bk3xtMXfZ94gqFDtg/GkI7e9zqGh5Beg=
 go.opentelemetry.io/otel v1.42.0 h1:lSQGzTgVR3+sgJDAU/7/ZMjN9Z+vUip7leaqBKy4sho=
 go.opentelemetry.io/otel v1.42.0/go.mod h1:lJNsdRMxCUIWuMlVJWzecSMuNjE7dOYyWlqOXWkdqCc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.39.0 h1:f0cb2XPmrqn4XMy9PNliTgRKJgS5WcL/u0/WRYGz4t0=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.39.0/go.mod h1:vnakAaFckOMiMtOIhFI2MNH4FYrZzXCYxmb1LlhoGz8=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.39.0 h1:in9O8ESIOlwJAEGTkkf34DesGRAc/Pn8qJ7k3r/42LM=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.39.0/go.mod h1:Rp0EXBm5tfnv0WL+ARyO/PHBEaEAT8UUHQ6AGJcSq6c=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.39.0 h1:Ckwye2FpXkYgiHX7fyVrN1uA/UYd9ounqqTuSNAv0k4=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.39.0/go.mod h1:teIFJh5pW2y+AN7riv6IBPX2DuesS3HgP39mwOspKwU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.42.0 h1:THuZiwpQZuHPul65w4WcwEnkX2QIuMT+UFoOrygtoJw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.42.0/go.mod h1:J2pvYM5NGHofZ2/Ru6zw/TNWnEQp5crgyDeSrYpXkAw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.42.0 h1:zWWrB1U6nqhS/k6zYB74CjRpuiitRtLLi68VcgmOEto=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.42.0/go.mod h1:2qXPNBX1OVRC0IwOnfo1ljoid+RD0QK3443EaqVlsOU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.42.0 h1:uLXP+3mghfMf7XmV4PkGfFhFKuNWoCvvx5wP/wOXo0o=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.42.0/go.mod h1:v0Tj04armyT59mnURNUJf7RCKcKzq+lgJs6QSjHjaTc=
 go.opentelemetry.io/otel/metric v1.42.0 h1:2jXG+3oZLNXEPfNmnpxKDeZsFI5o4J+nz6xUlaFdF/4=
 go.opentelemetry.io/otel/metric v1.42.0/go.mod h1:RlUN/7vTU7Ao/diDkEpQpnz3/92J9ko05BIwxYa2SSI=
 go.opentelemetry.io/otel/sdk v1.42.0 h1:LyC8+jqk6UJwdrI/8VydAq/hvkFKNHZVIWuslJXYsDo=
@@ -525,8 +525,8 @@ google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
 google.golang.org/genproto/googleapis/api v0.0.0-20260209200024-4cfbd4190f57 h1:JLQynH/LBHfCTSbDWl+py8C+Rg/k1OVH3xfcaiANuF0=
 google.golang.org/genproto/googleapis/api v0.0.0-20260209200024-4cfbd4190f57/go.mod h1:kSJwQxqmFXeo79zOmbrALdflXQeAYcUbgS7PbpMknCY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57 h1:mWPCjDEyshlQYzBpMNHaEof6UX1PmHcaUODUywQ0uac=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57/go.mod h1:j9x/tPzZkyxcgEFkiKEEGxfvyumM01BEtsW8xzOahRQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171 h1:ggcbiqK8WWh6l1dnltU4BgWGIGo+EVYxCaAPih/zQXQ=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/config.go b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/config.go
index 2dc8eaea93a3b..2a64fd330cc5b 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/config.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/config.go
@@ -31,14 +31,16 @@ type Filter func(*stats.RPCTagInfo) bool
 
 // config is a group of options for this instrumentation.
 type config struct {
-	Filter            Filter
-	InterceptorFilter InterceptorFilter
-	Propagators       propagation.TextMapPropagator
-	TracerProvider    trace.TracerProvider
-	MeterProvider     metric.MeterProvider
-	SpanStartOptions  []trace.SpanStartOption
-	SpanAttributes    []attribute.KeyValue
-	MetricAttributes  []attribute.KeyValue
+	Filter             Filter
+	InterceptorFilter  InterceptorFilter
+	Propagators        propagation.TextMapPropagator
+	TracerProvider     trace.TracerProvider
+	MeterProvider      metric.MeterProvider
+	SpanKind           trace.SpanKind
+	SpanStartOptions   []trace.SpanStartOption
+	SpanAttributes     []attribute.KeyValue
+	MetricAttributes   []attribute.KeyValue
+	MetricAttributesFn func(ctx context.Context) []attribute.KeyValue
 
 	PublicEndpoint   bool
 	PublicEndpointFn func(ctx context.Context, info *stats.RPCTagInfo) bool
@@ -125,7 +127,9 @@ func WithFilter(f Filter) Option {
 // creating a Tracer.
 func WithTracerProvider(tp trace.TracerProvider) Option {
 	return optionFunc(func(c *config) {
-		c.TracerProvider = tp
+		if tp != nil {
+			c.TracerProvider = tp
+		}
 	})
 }
 
@@ -133,7 +137,9 @@ func WithTracerProvider(tp trace.TracerProvider) Option {
 // creating a Meter. If this option is not provide the global MeterProvider will be used.
 func WithMeterProvider(mp metric.MeterProvider) Option {
 	return optionFunc(func(c *config) {
-		c.MeterProvider = mp
+		if mp != nil {
+			c.MeterProvider = mp
+		}
 	})
 }
 
@@ -176,6 +182,18 @@ func WithSpanOptions(opts ...trace.SpanStartOption) Option {
 	})
 }
 
+// WithSpanKind returns an Option to set the span kind for spans created by
+// the handler.
+//
+// By default, [NewServerHandler] creates spans with
+// [trace.SpanKindServer] and [NewClientHandler] creates spans with
+// [trace.SpanKindClient].
+func WithSpanKind(sk trace.SpanKind) Option {
+	return optionFunc(func(c *config) {
+		c.SpanKind = sk
+	})
+}
+
 // WithSpanAttributes returns an Option to add custom attributes to the spans.
 func WithSpanAttributes(a ...attribute.KeyValue) Option {
 	return optionFunc(func(c *config) {
@@ -193,3 +211,15 @@ func WithMetricAttributes(a ...attribute.KeyValue) Option {
 		}
 	})
 }
+
+// WithMetricAttributesFn returns an Option to add dynamic custom attributes to the handler's metrics.
+// The function is called once per RPC and the returned attributes are applied to all metrics recorded by this handler.
+//
+// The context parameter is the standard gRPC request context and provides access to request-scoped data.
+func WithMetricAttributesFn(fn func(ctx context.Context) []attribute.KeyValue) Option {
+	return optionFunc(func(c *config) {
+		if fn != nil {
+			c.MetricAttributesFn = fn
+		}
+	})
+}
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go
index 99f88ec3b9958..69e8506ffd259 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/interceptor.go
@@ -11,7 +11,7 @@ import (
 
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
-	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
 	grpc_codes "google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go
index e46185e0b1244..7d7f172e0a48e 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal/parse.go
@@ -8,7 +8,7 @@ import (
 	"strings"
 
 	"go.opentelemetry.io/otel/attribute"
-	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
 )
 
 // ParseFullMethod returns a span name following the OpenTelemetry semantic
@@ -23,19 +23,5 @@ func ParseFullMethod(fullMethod string) (string, []attribute.KeyValue) {
 		return fullMethod, nil
 	}
 	name := fullMethod[1:]
-	pos := strings.LastIndex(name, "/")
-	if pos < 0 {
-		// Invalid format, does not follow `/package.service/method`.
-		return name, nil
-	}
-	service, method := name[:pos], name[pos+1:]
-
-	var attrs []attribute.KeyValue
-	if service != "" {
-		attrs = append(attrs, semconv.RPCService(service))
-	}
-	if method != "" {
-		attrs = append(attrs, semconv.RPCMethod(method))
-	}
-	return name, attrs
+	return name, []attribute.KeyValue{semconv.RPCMethod(name)}
 }
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go
index 278f6d0d99ef6..be9282f29f630 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/stats_handler.go
@@ -5,15 +5,15 @@ package otelgrpc // import "go.opentelemetry.io/contrib/instrumentation/google.g
 
 import (
 	"context"
-	"sync/atomic"
+	"strconv"
 	"time"
 
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/metric"
-	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
-	"go.opentelemetry.io/otel/semconv/v1.37.0/rpcconv"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/rpcconv"
 	"go.opentelemetry.io/otel/trace"
 	grpc_codes "google.golang.org/grpc/codes"
 	"google.golang.org/grpc/peer"
@@ -26,11 +26,8 @@ import (
 type gRPCContextKey struct{}
 
 type gRPCContext struct {
-	inMessages    int64
-	outMessages   int64
-	metricAttrs   []attribute.KeyValue
-	metricAttrSet attribute.Set
-	record        bool
+	metricAttrs []attribute.KeyValue
+	record      bool
 }
 
 type serverHandler struct {
@@ -38,51 +35,37 @@ type serverHandler struct {
 
 	tracer trace.Tracer
 
-	duration rpcconv.ServerDuration
-	inSize   int64Hist
-	outSize  int64Hist
-	inMsg    rpcconv.ServerRequestsPerRPC
-	outMsg   rpcconv.ServerResponsesPerRPC
+	duration rpcconv.ServerCallDuration
 }
 
 // NewServerHandler creates a stats.Handler for a gRPC server.
 func NewServerHandler(opts ...Option) stats.Handler {
 	c := newConfig(opts)
+	if c.SpanKind == trace.SpanKindUnspecified {
+		c.SpanKind = trace.SpanKindServer
+	}
+
 	h := &serverHandler{config: c}
 
 	h.tracer = c.TracerProvider.Tracer(
 		ScopeName,
-		trace.WithInstrumentationVersion(Version()),
+		trace.WithInstrumentationVersion(Version),
 	)
 
 	meter := c.MeterProvider.Meter(
 		ScopeName,
-		metric.WithInstrumentationVersion(Version()),
+		metric.WithInstrumentationVersion(Version),
 		metric.WithSchemaURL(semconv.SchemaURL),
 	)
 
 	var err error
-	h.duration, err = rpcconv.NewServerDuration(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.inSize, err = rpcconv.NewServerRequestSize(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.outSize, err = rpcconv.NewServerResponseSize(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.inMsg, err = rpcconv.NewServerRequestsPerRPC(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.outMsg, err = rpcconv.NewServerResponsesPerRPC(meter)
+	h.duration, err = rpcconv.NewServerCallDuration(
+		meter,
+		metric.WithExplicitBucketBoundaries(
+			0.005, 0.01, 0.025, 0.05, 0.075, 0.1,
+			0.25, 0.5, 0.75, 1, 2.5, 5, 7.5, 10,
+		),
+	)
 	if err != nil {
 		otel.Handle(err)
 	}
@@ -104,7 +87,7 @@ func (h *serverHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) cont
 	ctx = extract(ctx, h.Propagators)
 
 	name, attrs := internal.ParseFullMethod(info.FullMethodName)
-	attrs = append(attrs, semconv.RPCSystemGRPC)
+	attrs = append(attrs, semconv.RPCSystemNameGRPC)
 
 	record := true
 	if h.Filter != nil {
@@ -116,7 +99,7 @@ func (h *serverHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) cont
 		spanAttributes := make([]attribute.KeyValue, 0, len(attrs)+len(h.SpanAttributes))
 		spanAttributes = append(append(spanAttributes, attrs...), h.SpanAttributes...)
 		opts := []trace.SpanStartOption{
-			trace.WithSpanKind(trace.SpanKindServer),
+			trace.WithSpanKind(h.SpanKind),
 			trace.WithAttributes(spanAttributes...),
 		}
 		if h.PublicEndpoint || (h.PublicEndpointFn != nil && h.PublicEndpointFn(ctx, info)) {
@@ -137,7 +120,11 @@ func (h *serverHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) cont
 		metricAttrs: append(attrs, h.MetricAttributes...),
 		record:      record,
 	}
-	gctx.metricAttrSet = attribute.NewSet(gctx.metricAttrs...)
+
+	if h.MetricAttributesFn != nil {
+		extraAttrs := h.MetricAttributesFn(ctx)
+		gctx.metricAttrs = append(gctx.metricAttrs, extraAttrs...)
+	}
 
 	return context.WithValue(ctx, gRPCContextKey{}, &gctx)
 }
@@ -148,10 +135,6 @@ func (h *serverHandler) HandleRPC(ctx context.Context, rs stats.RPCStats) {
 		ctx,
 		rs,
 		h.duration.Inst(),
-		h.inSize,
-		h.outSize,
-		h.inMsg.Inst(),
-		h.outMsg.Inst(),
 		serverStatus,
 	)
 }
@@ -161,51 +144,37 @@ type clientHandler struct {
 
 	tracer trace.Tracer
 
-	duration rpcconv.ClientDuration
-	inSize   int64Hist
-	outSize  int64Hist
-	inMsg    rpcconv.ClientResponsesPerRPC
-	outMsg   rpcconv.ClientRequestsPerRPC
+	duration rpcconv.ClientCallDuration
 }
 
 // NewClientHandler creates a stats.Handler for a gRPC client.
 func NewClientHandler(opts ...Option) stats.Handler {
 	c := newConfig(opts)
+	if c.SpanKind == trace.SpanKindUnspecified {
+		c.SpanKind = trace.SpanKindClient
+	}
+
 	h := &clientHandler{config: c}
 
 	h.tracer = c.TracerProvider.Tracer(
 		ScopeName,
-		trace.WithInstrumentationVersion(Version()),
+		trace.WithInstrumentationVersion(Version),
 	)
 
 	meter := c.MeterProvider.Meter(
 		ScopeName,
-		metric.WithInstrumentationVersion(Version()),
+		metric.WithInstrumentationVersion(Version),
 		metric.WithSchemaURL(semconv.SchemaURL),
 	)
 
 	var err error
-	h.duration, err = rpcconv.NewClientDuration(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.inSize, err = rpcconv.NewClientResponseSize(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.outSize, err = rpcconv.NewClientRequestSize(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.inMsg, err = rpcconv.NewClientResponsesPerRPC(meter)
-	if err != nil {
-		otel.Handle(err)
-	}
-
-	h.outMsg, err = rpcconv.NewClientRequestsPerRPC(meter)
+	h.duration, err = rpcconv.NewClientCallDuration(
+		meter,
+		metric.WithExplicitBucketBoundaries(
+			0.005, 0.01, 0.025, 0.05, 0.075, 0.1,
+			0.25, 0.5, 0.75, 1, 2.5, 5, 7.5, 10,
+		),
+	)
 	if err != nil {
 		otel.Handle(err)
 	}
@@ -216,7 +185,7 @@ func NewClientHandler(opts ...Option) stats.Handler {
 // TagRPC can attach some information to the given context.
 func (h *clientHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) context.Context {
 	name, attrs := internal.ParseFullMethod(info.FullMethodName)
-	attrs = append(attrs, semconv.RPCSystemGRPC)
+	attrs = append(attrs, semconv.RPCSystemNameGRPC)
 
 	record := true
 	if h.Filter != nil {
@@ -230,7 +199,7 @@ func (h *clientHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) cont
 		ctx, _ = h.tracer.Start(
 			ctx,
 			name,
-			trace.WithSpanKind(trace.SpanKindClient),
+			trace.WithSpanKind(h.SpanKind),
 			trace.WithAttributes(spanAttributes...),
 		)
 	}
@@ -239,7 +208,11 @@ func (h *clientHandler) TagRPC(ctx context.Context, info *stats.RPCTagInfo) cont
 		metricAttrs: append(attrs, h.MetricAttributes...),
 		record:      record,
 	}
-	gctx.metricAttrSet = attribute.NewSet(gctx.metricAttrs...)
+
+	if h.MetricAttributesFn != nil {
+		extraAttrs := h.MetricAttributesFn(ctx)
+		gctx.metricAttrs = append(gctx.metricAttrs, extraAttrs...)
+	}
 
 	return inject(context.WithValue(ctx, gRPCContextKey{}, &gctx), h.Propagators)
 }
@@ -250,10 +223,6 @@ func (h *clientHandler) HandleRPC(ctx context.Context, rs stats.RPCStats) {
 		ctx,
 		rs,
 		h.duration.Inst(),
-		h.inSize,
-		h.outSize,
-		h.inMsg.Inst(),
-		h.outMsg.Inst(),
 		func(s *status.Status) (codes.Code, string) {
 			return codes.Error, s.Message()
 		},
@@ -270,16 +239,10 @@ func (*clientHandler) HandleConn(context.Context, stats.ConnStats) {
 	// no-op
 }
 
-type int64Hist interface {
-	RecordSet(context.Context, int64, attribute.Set)
-}
-
-func (c *config) handleRPC(
+func (*config) handleRPC(
 	ctx context.Context,
 	rs stats.RPCStats,
 	duration metric.Float64Histogram,
-	inSize, outSize int64Hist,
-	inMsg, outMsg metric.Int64Histogram,
 	recordStatus func(*status.Status) (codes.Code, string),
 ) {
 	gctx, _ := ctx.Value(gRPCContextKey{}).(*gRPCContext)
@@ -288,42 +251,11 @@ func (c *config) handleRPC(
 	}
 
 	span := trace.SpanFromContext(ctx)
-	var messageId int64
 
 	switch rs := rs.(type) {
 	case *stats.Begin:
 	case *stats.InPayload:
-		if gctx != nil {
-			messageId = atomic.AddInt64(&gctx.inMessages, 1)
-			inSize.RecordSet(ctx, int64(rs.Length), gctx.metricAttrSet)
-		}
-
-		if c.ReceivedEvent && span.IsRecording() {
-			span.AddEvent("message",
-				trace.WithAttributes(
-					semconv.RPCMessageTypeReceived,
-					semconv.RPCMessageIDKey.Int64(messageId),
-					semconv.RPCMessageCompressedSizeKey.Int(rs.CompressedLength),
-					semconv.RPCMessageUncompressedSizeKey.Int(rs.Length),
-				),
-			)
-		}
 	case *stats.OutPayload:
-		if gctx != nil {
-			messageId = atomic.AddInt64(&gctx.outMessages, 1)
-			outSize.RecordSet(ctx, int64(rs.Length), gctx.metricAttrSet)
-		}
-
-		if c.SentEvent && span.IsRecording() {
-			span.AddEvent("message",
-				trace.WithAttributes(
-					semconv.RPCMessageTypeSent,
-					semconv.RPCMessageIDKey.Int64(messageId),
-					semconv.RPCMessageCompressedSizeKey.Int(rs.CompressedLength),
-					semconv.RPCMessageUncompressedSizeKey.Int(rs.Length),
-				),
-			)
-		}
 	case *stats.OutTrailer:
 	case *stats.OutHeader:
 		if span.IsRecording() {
@@ -337,9 +269,9 @@ func (c *config) handleRPC(
 		var s *status.Status
 		if rs.Error != nil {
 			s, _ = status.FromError(rs.Error)
-			rpcStatusAttr = semconv.RPCGRPCStatusCodeKey.Int(int(s.Code()))
+			rpcStatusAttr = semconv.RPCResponseStatusCode(canonicalString(s.Code()))
 		} else {
-			rpcStatusAttr = semconv.RPCGRPCStatusCodeKey.Int(int(grpc_codes.OK))
+			rpcStatusAttr = semconv.RPCResponseStatusCode(canonicalString(grpc_codes.OK))
 		}
 		if span.IsRecording() {
 			if s != nil {
@@ -364,14 +296,51 @@ func (c *config) handleRPC(
 
 		// Use floating point division here for higher precision (instead of Millisecond method).
 		// Measure right before calling Record() to capture as much elapsed time as possible.
-		elapsedTime := float64(rs.EndTime.Sub(rs.BeginTime)) / float64(time.Millisecond)
+		elapsedTime := float64(rs.EndTime.Sub(rs.BeginTime)) / float64(time.Second)
 
 		duration.Record(ctx, elapsedTime, recordOpts...)
-		if gctx != nil {
-			inMsg.Record(ctx, atomic.LoadInt64(&gctx.inMessages), recordOpts...)
-			outMsg.Record(ctx, atomic.LoadInt64(&gctx.outMessages), recordOpts...)
-		}
 	default:
 		return
 	}
 }
+
+func canonicalString(code grpc_codes.Code) string {
+	switch code {
+	case grpc_codes.OK:
+		return "OK"
+	case grpc_codes.Canceled:
+		return "CANCELLED"
+	case grpc_codes.Unknown:
+		return "UNKNOWN"
+	case grpc_codes.InvalidArgument:
+		return "INVALID_ARGUMENT"
+	case grpc_codes.DeadlineExceeded:
+		return "DEADLINE_EXCEEDED"
+	case grpc_codes.NotFound:
+		return "NOT_FOUND"
+	case grpc_codes.AlreadyExists:
+		return "ALREADY_EXISTS"
+	case grpc_codes.PermissionDenied:
+		return "PERMISSION_DENIED"
+	case grpc_codes.ResourceExhausted:
+		return "RESOURCE_EXHAUSTED"
+	case grpc_codes.FailedPrecondition:
+		return "FAILED_PRECONDITION"
+	case grpc_codes.Aborted:
+		return "ABORTED"
+	case grpc_codes.OutOfRange:
+		return "OUT_OF_RANGE"
+	case grpc_codes.Unimplemented:
+		return "UNIMPLEMENTED"
+	case grpc_codes.Internal:
+		return "INTERNAL"
+	case grpc_codes.Unavailable:
+		return "UNAVAILABLE"
+	case grpc_codes.DataLoss:
+		return "DATA_LOSS"
+	case grpc_codes.Unauthenticated:
+		return "UNAUTHENTICATED"
+	default:
+		return "CODE(" + strconv.FormatInt(int64(code), 10) + ")"
+	}
+}
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/version.go b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/version.go
index 98f148be5dd04..535e63a07b368 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/version.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/version.go
@@ -4,7 +4,4 @@
 package otelgrpc // import "go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
 
 // Version is the current release version of the gRPC instrumentation.
-func Version() string {
-	return "0.64.0"
-	// This string is updated by the pre_release.sh script during release
-}
+const Version = "0.67.0"
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/client.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/client.go
deleted file mode 100644
index e980ab62b85c1..0000000000000
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/client.go
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-package otelhttp // import "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
-
-import (
-	"context"
-	"io"
-	"net/http"
-	"net/url"
-	"strings"
-)
-
-// DefaultClient is the default Client and is used by Get, Head, Post and PostForm.
-// Please be careful of initialization order - for example, if you change
-// the global propagator, the DefaultClient might still be using the old one.
-//
-// Deprecated: [DefaultClient] will be removed in a future release.
-// Create your own [http.Client] based on the [Transport] example: https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp#example-NewTransport
-var DefaultClient = &http.Client{Transport: NewTransport(http.DefaultTransport)}
-
-// Get is a convenient replacement for http.Get that adds a span around the request.
-//
-// Deprecated: [Get] will be removed in a future release.
-// Create your own [http.Client] based on the [Transport] example: https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp#example-NewTransport
-func Get(ctx context.Context, targetURL string) (resp *http.Response, err error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, targetURL, http.NoBody)
-	if err != nil {
-		return nil, err
-	}
-	return DefaultClient.Do(req)
-}
-
-// Head is a convenient replacement for http.Head that adds a span around the request.
-//
-// Deprecated: [Head] will be removed in a future release.
-// Create your own [http.Client] based on the [Transport] example: https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp#example-NewTransport
-func Head(ctx context.Context, targetURL string) (resp *http.Response, err error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodHead, targetURL, http.NoBody)
-	if err != nil {
-		return nil, err
-	}
-	return DefaultClient.Do(req)
-}
-
-// Post is a convenient replacement for http.Post that adds a span around the request.
-//
-// Deprecated: [Post] will be removed in a future release.
-// Create your own [http.Client] based on the [Transport] example: https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp#example-NewTransport
-func Post(ctx context.Context, targetURL, contentType string, body io.Reader) (resp *http.Response, err error) {
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, body)
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Set("Content-Type", contentType)
-	return DefaultClient.Do(req)
-}
-
-// PostForm is a convenient replacement for http.PostForm that adds a span around the request.
-//
-// Deprecated: [PostForm] will be removed in a future release.
-// Create your own [http.Client] based on the [Transport] example: https://pkg.go.dev/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp#example-NewTransport
-func PostForm(ctx context.Context, targetURL string, data url.Values) (resp *http.Response, err error) {
-	return Post(ctx, targetURL, "application/x-www-form-urlencoded", strings.NewReader(data.Encode()))
-}
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/common.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/common.go
index a83a026274a11..3ae0824344171 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/common.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/common.go
@@ -23,5 +23,5 @@ const (
 type Filter func(*http.Request) bool
 
 func newTracer(tp trace.TracerProvider) trace.Tracer {
-	return tp.Tracer(ScopeName, trace.WithInstrumentationVersion(Version()))
+	return tp.Tracer(ScopeName, trace.WithInstrumentationVersion(Version))
 }
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/config.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/config.go
index c3be78616b223..a7d4b2a815c6f 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/config.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/config.go
@@ -66,7 +66,7 @@ func newConfig(opts ...Option) *config {
 
 	c.Meter = c.MeterProvider.Meter(
 		ScopeName,
-		metric.WithInstrumentationVersion(Version()),
+		metric.WithInstrumentationVersion(Version),
 	)
 
 	return c
@@ -92,18 +92,6 @@ func WithMeterProvider(provider metric.MeterProvider) Option {
 	})
 }
 
-// WithPublicEndpoint configures the Handler to link the span with an incoming
-// span context. If this option is not provided, then the association is a child
-// association instead of a link.
-//
-// Deprecated: Use [WithPublicEndpointFn] instead.
-// To migrate, replace WithPublicEndpoint() with:
-//
-//	WithPublicEndpointFn(func(*http.Request) bool { return true })
-func WithPublicEndpoint() Option {
-	return WithPublicEndpointFn(func(*http.Request) bool { return true })
-}
-
 // WithPublicEndpointFn runs with every request, and allows conditionally
 // configuring the Handler to link the span with an incoming span context. If
 // this option is not provided or returns false, then the association is a
@@ -206,6 +194,9 @@ func WithServerName(server string) Option {
 
 // WithMetricAttributesFn returns an Option to set a function that maps an HTTP request to a slice of attribute.KeyValue.
 // These attributes will be included in metrics for every request.
+//
+// Deprecated: WithMetricAttributesFn is deprecated and will be removed in a
+// future release. Use [Labeler] instead.
 func WithMetricAttributesFn(metricAttributesFn func(r *http.Request) []attribute.KeyValue) Option {
 	return optionFunc(func(c *config) {
 		c.MetricAttributesFn = metricAttributesFn
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/handler.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/handler.go
index c1bbf3a3c2d2c..a269fce0f7a17 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/handler.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/handler.go
@@ -184,30 +184,26 @@ func (h *middleware) serveHTTP(w http.ResponseWriter, r *http.Request, next http
 	statusCode := rww.StatusCode()
 	bytesWritten := rww.BytesWritten()
 	span.SetStatus(h.semconv.Status(statusCode))
+	bytesRead := bw.BytesRead()
 	span.SetAttributes(h.semconv.ResponseTraceAttrs(semconv.ResponseTelemetry{
 		StatusCode: statusCode,
-		ReadBytes:  bw.BytesRead(),
+		ReadBytes:  bytesRead,
 		ReadError:  bw.Error(),
 		WriteBytes: bytesWritten,
 		WriteError: rww.Error(),
 	})...)
 
-	// Use floating point division here for higher precision (instead of Millisecond method).
-	elapsedTime := float64(time.Since(requestStartTime)) / float64(time.Millisecond)
-
-	metricAttributes := semconv.MetricAttributes{
-		Req:                  r,
-		StatusCode:           statusCode,
-		AdditionalAttributes: append(labeler.Get(), h.metricAttributesFromRequest(r)...),
-	}
-
 	h.semconv.RecordMetrics(ctx, semconv.ServerMetricData{
-		ServerName:       h.server,
-		ResponseSize:     bytesWritten,
-		MetricAttributes: metricAttributes,
+		ServerName:   h.server,
+		ResponseSize: bytesWritten,
+		MetricAttributes: semconv.MetricAttributes{
+			Req:                  r,
+			StatusCode:           statusCode,
+			AdditionalAttributes: append(labeler.Get(), h.metricAttributesFromRequest(r)...),
+		},
 		MetricData: semconv.MetricData{
-			RequestSize: bw.BytesRead(),
-			ElapsedTime: elapsedTime,
+			RequestSize:     bytesRead,
+			RequestDuration: time.Since(requestStartTime),
 		},
 	})
 }
@@ -219,21 +215,3 @@ func (h *middleware) metricAttributesFromRequest(r *http.Request) []attribute.Ke
 	}
 	return attributeForRequest
 }
-
-// WithRouteTag annotates spans and metrics with the provided route name
-// with HTTP route attribute.
-//
-// Deprecated: spans are automatically annotated with the route attribute.
-// To annotate metrics, use the [WithMetricAttributesFn] option.
-func WithRouteTag(route string, h http.Handler) http.Handler {
-	attr := semconv.NewHTTPServer(nil).Route(route)
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		span := trace.SpanFromContext(r.Context())
-		span.SetAttributes(attr)
-
-		labeler, _ := LabelerFromContext(r.Context())
-		labeler.Add(attr)
-
-		h.ServeHTTP(w, r)
-	})
-}
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/request/resp_writer_wrapper.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/request/resp_writer_wrapper.go
index ca2e4c14c7156..f29f9b7c962a3 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/request/resp_writer_wrapper.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/request/resp_writer_wrapper.go
@@ -61,7 +61,7 @@ func (w *RespWriterWrapper) Write(p []byte) (int, error) {
 
 // WriteHeader persists initial statusCode for span attribution.
 // All calls to WriteHeader will be propagated to the underlying ResponseWriter
-// and will persist the statusCode from the first call.
+// and will persist the statusCode from the first call (except for informational response status codes).
 // Blocking consecutive calls to WriteHeader alters expected behavior and will
 // remove warning logs from net/http where developers will notice incorrect handler implementations.
 func (w *RespWriterWrapper) WriteHeader(statusCode int) {
@@ -77,6 +77,13 @@ func (w *RespWriterWrapper) WriteHeader(statusCode int) {
 // parent method.
 func (w *RespWriterWrapper) writeHeader(statusCode int) {
 	if !w.wroteHeader {
+		// Ignore informational response status codes.
+		// Based on https://github.com/golang/go/blob/go1.24.1/src/net/http/server.go#L1216
+		if statusCode >= 100 && statusCode <= 199 && statusCode != http.StatusSwitchingProtocols {
+			w.ResponseWriter.WriteHeader(statusCode)
+			return
+		}
+
 		w.wroteHeader = true
 		w.statusCode = statusCode
 	}
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/client.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/client.go
index 45d3d934f5234..1398d85c2e9f3 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/client.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/client.go
@@ -12,7 +12,6 @@ import (
 	"context"
 	"fmt"
 	"net/http"
-	"reflect"
 	"slices"
 	"strconv"
 	"strings"
@@ -20,11 +19,11 @@ import (
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/semconv/v1.37.0"
-	"go.opentelemetry.io/otel/semconv/v1.37.0/httpconv"
+	"go.opentelemetry.io/otel/semconv/v1.40.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/httpconv"
 )
 
-type HTTPClient struct{
+type HTTPClient struct {
 	requestBodySize httpconv.ClientRequestBodySize
 	requestDuration httpconv.ClientRequestDuration
 }
@@ -58,14 +57,14 @@ func (n HTTPClient) Status(code int) (codes.Code, string) {
 // RequestTraceAttrs returns trace attributes for an HTTP request made by a client.
 func (n HTTPClient) RequestTraceAttrs(req *http.Request) []attribute.KeyValue {
 	/*
-		 below attributes are returned:
-		 - http.request.method
-		 - http.request.method.original
-		 - url.full
-		 - server.address
-		 - server.port
-		 - network.protocol.name
-		 - network.protocol.version
+	 below attributes are returned:
+	 - http.request.method
+	 - http.request.method.original
+	 - url.full
+	 - server.address
+	 - server.port
+	 - network.protocol.name
+	 - network.protocol.version
 	*/
 	numOfAttributes := 3 // URL, server address, proto, and method.
 
@@ -140,9 +139,9 @@ func (n HTTPClient) RequestTraceAttrs(req *http.Request) []attribute.KeyValue {
 // ResponseTraceAttrs returns trace attributes for an HTTP response made by a client.
 func (n HTTPClient) ResponseTraceAttrs(resp *http.Response) []attribute.KeyValue {
 	/*
-		 below attributes are returned:
-		 - http.response.status_code
-		 - error.type
+	 below attributes are returned:
+	 - http.response.status_code
+	 - error.type
 	*/
 	var count int
 	if resp.StatusCode > 0 {
@@ -165,23 +164,6 @@ func (n HTTPClient) ResponseTraceAttrs(resp *http.Response) []attribute.KeyValue
 	return attrs
 }
 
-func (n HTTPClient) ErrorType(err error) attribute.KeyValue {
-	t := reflect.TypeOf(err)
-	var value string
-	if t.PkgPath() == "" && t.Name() == "" {
-		// Likely a builtin type.
-		value = t.String()
-	} else {
-		value = fmt.Sprintf("%s.%s", t.PkgPath(), t.Name())
-	}
-
-	if value == "" {
-		return semconv.ErrorTypeOther
-	}
-
-	return semconv.ErrorTypeKey.String(value)
-}
-
 func (n HTTPClient) method(method string) (attribute.KeyValue, attribute.KeyValue) {
 	if method == "" {
 		return semconv.HTTPRequestMethodGet, attribute.KeyValue{}
@@ -265,22 +247,26 @@ func (o MetricOpts) AddOptions() metric.AddOption {
 	return o.addOptions
 }
 
-func (n HTTPClient) MetricOptions(ma MetricAttributes) map[string]MetricOpts {
-	opts := map[string]MetricOpts{}
-
+func (n HTTPClient) MetricOptions(ma MetricAttributes) MetricOpts {
 	attributes := n.MetricAttributes(ma.Req, ma.StatusCode, ma.AdditionalAttributes)
 	set := metric.WithAttributeSet(attribute.NewSet(attributes...))
-	opts["new"] = MetricOpts{
+
+	return MetricOpts{
 		measurement: set,
 		addOptions:  set,
 	}
-
-	return opts
 }
 
-func (n HTTPClient) RecordMetrics(ctx context.Context, md MetricData, opts map[string]MetricOpts) {
-	n.requestBodySize.Inst().Record(ctx, md.RequestSize, opts["new"].MeasurementOption())
-	n.requestDuration.Inst().Record(ctx, md.ElapsedTime/1000, opts["new"].MeasurementOption())
+func (n HTTPClient) RecordMetrics(ctx context.Context, md MetricData, opts MetricOpts) {
+	recordOpts := metricRecordOptionPool.Get().(*[]metric.RecordOption)
+	defer func() {
+		*recordOpts = (*recordOpts)[:0]
+		metricRecordOptionPool.Put(recordOpts)
+	}()
+	*recordOpts = append(*recordOpts, opts.MeasurementOption())
+
+	n.requestBodySize.Inst().Record(ctx, md.RequestSize, *recordOpts...)
+	n.requestDuration.Inst().Record(ctx, durationToSeconds(md.RequestDuration), *recordOpts...)
 }
 
 // TraceAttributes returns attributes for httptrace.
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/server.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/server.go
index 5ae6a07386baf..6dcf1b5b52b90 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/server.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/server.go
@@ -15,12 +15,13 @@ import (
 	"slices"
 	"strings"
 	"sync"
+	"time"
 
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/semconv/v1.37.0"
-	"go.opentelemetry.io/otel/semconv/v1.37.0/httpconv"
+	"go.opentelemetry.io/otel/semconv/v1.40.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/httpconv"
 )
 
 type RequestTraceAttrsOpts struct {
@@ -36,7 +37,7 @@ type ResponseTelemetry struct {
 	WriteError error
 }
 
-type HTTPServer struct{
+type HTTPServer struct {
 	requestBodySizeHistogram  httpconv.ServerRequestBodySize
 	responseBodySizeHistogram httpconv.ServerResponseBodySize
 	requestDurationHistogram  httpconv.ServerRequestDuration
@@ -245,19 +246,11 @@ type MetricAttributes struct {
 }
 
 type MetricData struct {
-	RequestSize int64
-
-	// The request duration, in milliseconds
-	ElapsedTime float64
+	RequestSize     int64
+	RequestDuration time.Duration
 }
 
 var (
-	metricAddOptionPool = &sync.Pool{
-		New: func() any {
-			return &[]metric.AddOption{}
-		},
-	}
-
 	metricRecordOptionPool = &sync.Pool{
 		New: func() any {
 			return &[]metric.RecordOption{}
@@ -272,7 +265,7 @@ func (n HTTPServer) RecordMetrics(ctx context.Context, md ServerMetricData) {
 	*recordOpts = append(*recordOpts, o)
 	n.requestBodySizeHistogram.Inst().Record(ctx, md.RequestSize, *recordOpts...)
 	n.responseBodySizeHistogram.Inst().Record(ctx, md.ResponseSize, *recordOpts...)
-	n.requestDurationHistogram.Inst().Record(ctx, md.ElapsedTime/1000.0, o)
+	n.requestDurationHistogram.Inst().Record(ctx, durationToSeconds(md.RequestDuration), o)
 	*recordOpts = (*recordOpts)[:0]
 	metricRecordOptionPool.Put(recordOpts)
 }
@@ -373,8 +366,8 @@ func (n HTTPServer) MetricAttributes(server string, req *http.Request, statusCod
 	}
 
 	if route != "" {
-        num++
-    }
+		num++
+	}
 
 	attributes := slices.Grow(additionalAttributes, num)
 	attributes = append(attributes,
@@ -397,7 +390,7 @@ func (n HTTPServer) MetricAttributes(server string, req *http.Request, statusCod
 	}
 
 	if route != "" {
-        attributes = append(attributes, semconv.HTTPRoute(route))
-    }
+		attributes = append(attributes, semconv.HTTPRoute(route))
+	}
 	return attributes
 }
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/util.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/util.go
index 96422ad1ed276..2eab2ecabde4c 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/util.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv/util.go
@@ -11,10 +11,11 @@ import (
 	"net/http"
 	"strconv"
 	"strings"
+	"time"
 
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
-	semconvNew "go.opentelemetry.io/otel/semconv/v1.37.0"
+	semconvNew "go.opentelemetry.io/otel/semconv/v1.40.0"
 )
 
 // SplitHostPort splits a network address hostport of the form "host",
@@ -125,3 +126,8 @@ func standardizeHTTPMethod(method string) string {
 	}
 	return method
 }
+
+func durationToSeconds(d time.Duration) float64 {
+	// Use floating point division here for higher precision (instead of Seconds method).
+	return float64(d) / float64(time.Second)
+}
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/transport.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/transport.go
index 514ae6753b772..d8d204d1f8a08 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/transport.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/transport.go
@@ -15,6 +15,7 @@ import (
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/propagation"
+	otelsemconv "go.opentelemetry.io/otel/semconv/v1.40.0"
 	"go.opentelemetry.io/otel/trace"
 
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/request"
@@ -102,9 +103,7 @@ func (t *Transport) RoundTrip(r *http.Request) (*http.Response, error) {
 		}
 	}
 
-	opts := append([]trace.SpanStartOption{}, t.spanStartOptions...) // start with the configured options
-
-	ctx, span := tracer.Start(r.Context(), t.spanNameFormatter("", r), opts...)
+	ctx, span := tracer.Start(r.Context(), t.spanNameFormatter("", r), t.spanStartOptions...)
 
 	if t.clientTrace != nil {
 		ctx = httptrace.WithClientTrace(ctx, t.clientTrace(ctx))
@@ -117,12 +116,26 @@ func (t *Transport) RoundTrip(r *http.Request) (*http.Response, error) {
 
 	r = r.Clone(ctx) // According to RoundTripper spec, we shouldn't modify the origin request.
 
-	// if request body is nil or NoBody, we don't want to mutate the body as it
-	// will affect the identity of it in an unforeseeable way because we assert
-	// ReadCloser fulfills a certain interface and it is indeed nil or NoBody.
-	bw := request.NewBodyWrapper(r.Body, func(int64) {})
-	if r.Body != nil && r.Body != http.NoBody {
-		r.Body = bw
+	var lastBW *request.BodyWrapper // Records the last body wrapper. Can be nil.
+	maybeWrapBody := func(body io.ReadCloser) io.ReadCloser {
+		if body == nil || body == http.NoBody {
+			return body
+		}
+		bw := request.NewBodyWrapper(body, func(int64) {})
+		lastBW = bw
+		return bw
+	}
+	r.Body = maybeWrapBody(r.Body)
+	if r.GetBody != nil {
+		originalGetBody := r.GetBody
+		r.GetBody = func() (io.ReadCloser, error) {
+			b, err := originalGetBody()
+			if err != nil {
+				lastBW = nil // The underlying transport will fail to make a retry request, hence, record no data.
+				return nil, err
+			}
+			return maybeWrapBody(b), nil
+		}
 	}
 
 	span.SetAttributes(t.semconv.RequestTraceAttrs(r)...)
@@ -130,52 +143,38 @@ func (t *Transport) RoundTrip(r *http.Request) (*http.Response, error) {
 
 	res, err := t.rt.RoundTrip(r)
 
-	// Defer metrics recording function to record the metrics on error or no error.
-	defer func() {
-		metricAttributes := semconv.MetricAttributes{
+	// Record the metrics on error or no error.
+	statusCode := 0
+	if err == nil {
+		statusCode = res.StatusCode
+	}
+	var requestSize int64
+	if lastBW != nil {
+		requestSize = lastBW.BytesRead()
+	}
+	t.semconv.RecordMetrics(
+		ctx,
+		semconv.MetricData{
+			RequestSize:     requestSize,
+			RequestDuration: time.Since(requestStartTime),
+		},
+		t.semconv.MetricOptions(semconv.MetricAttributes{
 			Req:                  r,
+			StatusCode:           statusCode,
 			AdditionalAttributes: append(labeler.Get(), t.metricAttributesFromRequest(r)...),
-		}
-
-		if err == nil {
-			metricAttributes.StatusCode = res.StatusCode
-		}
-
-		metricOpts := t.semconv.MetricOptions(metricAttributes)
-
-		metricData := semconv.MetricData{
-			RequestSize: bw.BytesRead(),
-		}
-
-		if err == nil {
-			readRecordFunc := func(int64) {}
-			res.Body = newWrappedBody(span, readRecordFunc, res.Body)
-		}
-
-		// Use floating point division here for higher precision (instead of Millisecond method).
-		elapsedTime := float64(time.Since(requestStartTime)) / float64(time.Millisecond)
-
-		metricData.ElapsedTime = elapsedTime
-
-		t.semconv.RecordMetrics(ctx, metricData, metricOpts)
-	}()
+		}),
+	)
 
 	if err != nil {
-		// set error type attribute if the error is part of the predefined
-		// error types.
-		// otherwise, record it as an exception
-		if errType := t.semconv.ErrorType(err); errType.Valid() {
-			span.SetAttributes(errType)
-		} else {
-			span.RecordError(err)
-		}
-
+		span.SetAttributes(otelsemconv.ErrorType(err))
 		span.SetStatus(codes.Error, err.Error())
 		span.End()
 
 		return res, err
 	}
 
+	readRecordFunc := func(int64) {}
+	res.Body = newWrappedBody(span, readRecordFunc, res.Body)
 	// traces
 	span.SetAttributes(t.semconv.ResponseTraceAttrs(res)...)
 	span.SetStatus(t.semconv.Status(res.StatusCode))
@@ -229,7 +228,7 @@ func (wb *wrappedBody) Write(p []byte) (int, error) {
 	// This will not panic given the guard in newWrappedBody.
 	n, err := wb.body.(io.Writer).Write(p)
 	if err != nil {
-		wb.span.RecordError(err)
+		wb.span.SetAttributes(otelsemconv.ErrorType(err))
 		wb.span.SetStatus(codes.Error, err.Error())
 	}
 	return n, err
@@ -247,7 +246,7 @@ func (wb *wrappedBody) Read(b []byte) (int, error) {
 		wb.recordBytesRead()
 		wb.span.End()
 	default:
-		wb.span.RecordError(err)
+		wb.span.SetAttributes(otelsemconv.ErrorType(err))
 		wb.span.SetStatus(codes.Error, err.Error())
 	}
 	return n, err
diff --git a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/version.go b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/version.go
index 6e096da5e21d7..1d90fc264d418 100644
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/version.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/version.go
@@ -4,7 +4,4 @@
 package otelhttp // import "go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 
 // Version is the current release version of the otelhttp instrumentation.
-func Version() string {
-	return "0.64.0"
-	// This string is updated by the pre_release.sh script during release
-}
+const Version = "0.67.0"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go
index 76b7cd461bf92..258d0ca6a554e 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/client.go
@@ -62,7 +62,7 @@ func NewClient(opts ...Option) otlptrace.Client {
 func newClient(opts ...Option) *client {
 	cfg := otlpconfig.NewGRPCConfig(asGRPCOptions(opts)...)
 
-	ctx, cancel := context.WithCancel(context.Background())
+	ctx, cancel := context.WithCancel(context.Background()) //nolint:gosec  // cancel called in client shutdown.
 
 	c := &client{
 		endpoint:      cfg.Traces.Endpoint,
@@ -248,7 +248,7 @@ func (c *client) exportContext(parent context.Context) (context.Context, context
 	if c.exportTimeout > 0 {
 		ctx, cancel = context.WithTimeoutCause(parent, c.exportTimeout, errors.New("exporter export timeout"))
 	} else {
-		ctx, cancel = context.WithCancel(parent)
+		ctx, cancel = context.WithCancel(parent) //nolint:gosec  // cancel called by caller when export is complete.
 	}
 
 	if c.metadata.Len() > 0 {
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go
index 2257fcc865fd1..a84733174ec0d 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ/instrumentation.go
@@ -18,8 +18,8 @@ import (
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x"
 	"go.opentelemetry.io/otel/internal/global"
 	"go.opentelemetry.io/otel/metric"
-	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
-	"go.opentelemetry.io/otel/semconv/v1.37.0/otelconv"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
 )
 
 const (
@@ -116,7 +116,9 @@ func NewInstrumentation(id int64, target string) (*Instrumentation, error) {
 		// Do not modify attrs (NewSet sorts in-place), make a new slice.
 		recOpt: metric.WithAttributeSet(attribute.NewSet(append(
 			// Default to OK status code.
-			[]attribute.KeyValue{semconv.RPCGRPCStatusCodeOk},
+			[]attribute.KeyValue{
+				semconv.RPCResponseStatusCode(codes.OK.String()),
+			},
 			attrs...,
 		)...)),
 	}
@@ -206,10 +208,12 @@ func BaseAttrs(id int64, target string) []attribute.KeyValue {
 func (i *Instrumentation) ExportSpans(ctx context.Context, nSpans int) ExportOp {
 	start := time.Now()
 
-	addOpt := get[metric.AddOption](addOptPool)
-	defer put(addOptPool, addOpt)
-	*addOpt = append(*addOpt, i.addOpt)
-	i.inflightSpans.Add(ctx, int64(nSpans), *addOpt...)
+	if i.inflightSpans.Enabled(ctx) {
+		addOpt := get[metric.AddOption](addOptPool)
+		defer put(addOptPool, addOpt)
+		*addOpt = append(*addOpt, i.addOpt)
+		i.inflightSpans.Add(ctx, int64(nSpans), *addOpt...)
+	}
 
 	return ExportOp{
 		ctx:    ctx,
@@ -242,14 +246,18 @@ func (e ExportOp) End(err error, code codes.Code) {
 	defer put(addOptPool, addOpt)
 	*addOpt = append(*addOpt, e.inst.addOpt)
 
-	e.inst.inflightSpans.Add(e.ctx, -e.nSpans, *addOpt...)
+	if e.inst.inflightSpans.Enabled(e.ctx) {
+		e.inst.inflightSpans.Add(e.ctx, -e.nSpans, *addOpt...)
+	}
 
 	success := successful(e.nSpans, err)
 	// Record successfully exported spans, even if the value is 0 which are
 	// meaningful to distribution aggregations.
-	e.inst.exportedSpans.Add(e.ctx, success, *addOpt...)
+	if e.inst.exportedSpans.Enabled(e.ctx) {
+		e.inst.exportedSpans.Add(e.ctx, success, *addOpt...)
+	}
 
-	if err != nil {
+	if err != nil && e.inst.exportedSpans.Enabled(e.ctx) {
 		attrs := get[attribute.KeyValue](measureAttrsPool)
 		defer put(measureAttrsPool, attrs)
 		*attrs = append(*attrs, e.inst.attrs...)
@@ -264,12 +272,14 @@ func (e ExportOp) End(err error, code codes.Code) {
 		e.inst.exportedSpans.Add(e.ctx, e.nSpans-success, *addOpt...)
 	}
 
-	recOpt := get[metric.RecordOption](recordOptPool)
-	defer put(recordOptPool, recOpt)
-	*recOpt = append(*recOpt, e.inst.recordOption(err, code))
+	if e.inst.opDuration.Enabled(e.ctx) {
+		recOpt := get[metric.RecordOption](recordOptPool)
+		defer put(recordOptPool, recOpt)
+		*recOpt = append(*recOpt, e.inst.recordOption(err, code))
 
-	d := time.Since(e.start).Seconds()
-	e.inst.opDuration.Record(e.ctx, d, *recOpt...)
+		d := time.Since(e.start).Seconds()
+		e.inst.opDuration.Record(e.ctx, d, *recOpt...)
+	}
 }
 
 // recordOption returns a RecordOption with attributes representing the
@@ -291,8 +301,7 @@ func (i *Instrumentation) recordOption(err error, code codes.Code) metric.Record
 	defer put(measureAttrsPool, attrs)
 	*attrs = append(*attrs, i.attrs...)
 
-	c := int64(code) // uint32 -> int64.
-	*attrs = append(*attrs, semconv.RPCGRPCStatusCodeKey.Int64(c))
+	*attrs = append(*attrs, semconv.RPCResponseStatusCode(code.String()))
 	if err != nil {
 		*attrs = append(*attrs, semconv.ErrorType(err))
 	}
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go
index e2d7cee1e17e7..9d4b311920956 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/version.go
@@ -5,4 +5,4 @@ package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/ot
 
 // Version is the current release version of the OpenTelemetry OTLP gRPC trace
 // exporter in use.
-const Version = "1.39.0"
+const Version = "1.42.0"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/client.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/client.go
index d0688c2016fd2..05cb2334317c7 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/client.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/client.go
@@ -56,6 +56,8 @@ var ourTransport = &http.Transport{
 	ExpectContinueTimeout: 1 * time.Second,
 }
 
+var errInsecureEndpointWithTLS = errors.New("insecure HTTP endpoint cannot use TLS client configuration")
+
 type client struct {
 	name        string
 	cfg         otlpconfig.SignalConfig
@@ -110,6 +112,10 @@ func NewClient(opts ...Option) otlptrace.Client {
 
 // Start does nothing in a HTTP client.
 func (c *client) Start(ctx context.Context) error {
+	if c.cfg.Insecure && c.cfg.TLSCfg != nil {
+		return errInsecureEndpointWithTLS
+	}
+
 	// Initialize the instrumentation if not already done.
 	//
 	// Initialize here instead of NewClient to allow any errors to be passed
@@ -174,6 +180,7 @@ func (d *client) UploadTraces(ctx context.Context, protoSpans []*tracepb.Resourc
 		}
 
 		request.reset(ctx)
+		// nolint:gosec // URL is constructed from validated OTLP endpoint configuration
 		resp, err := d.client.Do(request.Request)
 		var urlErr *url.Error
 		if errors.As(err, &urlErr) && urlErr.Temporary() {
@@ -270,6 +277,7 @@ func (d *client) newRequest(body []byte) (request, error) {
 	case NoCompression:
 		r.ContentLength = int64(len(body))
 		req.bodyReader = bodyReader(body)
+		req.GetBody = bodyReaderErr(body)
 	case GzipCompression:
 		// Ensure the content length is not used.
 		r.ContentLength = -1
@@ -290,6 +298,7 @@ func (d *client) newRequest(body []byte) (request, error) {
 		}
 
 		req.bodyReader = bodyReader(b.Bytes())
+		req.GetBody = bodyReaderErr(b.Bytes())
 	}
 
 	return req, nil
@@ -315,6 +324,13 @@ func bodyReader(buf []byte) func() io.ReadCloser {
 	}
 }
 
+// bodyReaderErr returns a closure returning a new reader for buf.
+func bodyReaderErr(buf []byte) func() (io.ReadCloser, error) {
+	return func() (io.ReadCloser, error) {
+		return io.NopCloser(bytes.NewReader(buf)), nil
+	}
+}
+
 // request wraps an http.Request with a resettable body reader.
 type request struct {
 	*http.Request
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/observ/instrumentation.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/observ/instrumentation.go
index 326ef0f879963..3f2556e7a60d5 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/observ/instrumentation.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/observ/instrumentation.go
@@ -23,8 +23,8 @@ import (
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/x"
 	"go.opentelemetry.io/otel/internal/global"
 	"go.opentelemetry.io/otel/metric"
-	semconv "go.opentelemetry.io/otel/semconv/v1.37.0"
-	"go.opentelemetry.io/otel/semconv/v1.37.0/otelconv"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
 )
 
 const (
@@ -261,10 +261,12 @@ func parseIP(ip string) string {
 func (i *Instrumentation) ExportSpans(ctx context.Context, nSpans int) ExportOp {
 	start := time.Now()
 
-	addOpt := get[metric.AddOption](addOptPool)
-	defer put(addOptPool, addOpt)
-	*addOpt = append(*addOpt, i.addOpt)
-	i.inflightSpans.Add(ctx, int64(nSpans), *addOpt...)
+	if i.inflightSpans.Enabled(ctx) {
+		addOpt := get[metric.AddOption](addOptPool)
+		defer put(addOptPool, addOpt)
+		*addOpt = append(*addOpt, i.addOpt)
+		i.inflightSpans.Add(ctx, int64(nSpans), *addOpt...)
+	}
 
 	return ExportOp{
 		ctx:    ctx,
@@ -299,14 +301,18 @@ func (e ExportOp) End(err error, status int) {
 	defer put(addOptPool, addOpt)
 	*addOpt = append(*addOpt, e.inst.addOpt)
 
-	e.inst.inflightSpans.Add(e.ctx, -e.nSpans, *addOpt...)
+	if e.inst.inflightSpans.Enabled(e.ctx) {
+		e.inst.inflightSpans.Add(e.ctx, -e.nSpans, *addOpt...)
+	}
 
 	success := successful(e.nSpans, err)
 	// Record successfully exported spans, even if the value is 0 which are
 	// meaningful to distribution aggregations.
-	e.inst.exportedSpans.Add(e.ctx, success, *addOpt...)
+	if e.inst.exportedSpans.Enabled(e.ctx) {
+		e.inst.exportedSpans.Add(e.ctx, success, *addOpt...)
+	}
 
-	if err != nil {
+	if err != nil && e.inst.exportedSpans.Enabled(e.ctx) {
 		attrs := get[attribute.KeyValue](measureAttrsPool)
 		defer put(measureAttrsPool, attrs)
 		*attrs = append(*attrs, e.inst.attrs...)
@@ -321,12 +327,14 @@ func (e ExportOp) End(err error, status int) {
 		e.inst.exportedSpans.Add(e.ctx, e.nSpans-success, *addOpt...)
 	}
 
-	recOpt := get[metric.RecordOption](recordOptPool)
-	defer put(recordOptPool, recOpt)
-	*recOpt = append(*recOpt, e.inst.recordOption(err, status))
+	if e.inst.opDuration.Enabled(e.ctx) {
+		recOpt := get[metric.RecordOption](recordOptPool)
+		defer put(recordOptPool, recOpt)
+		*recOpt = append(*recOpt, e.inst.recordOption(err, status))
 
-	d := time.Since(e.start).Seconds()
-	e.inst.opDuration.Record(e.ctx, d, *recOpt...)
+		d := time.Since(e.start).Seconds()
+		e.inst.opDuration.Record(e.ctx, d, *recOpt...)
+	}
 }
 
 // recordOption returns a RecordOption with attributes representing the
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/version.go
index cbd6e63230b3d..c1e93d98c9a75 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/version.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/version.go
@@ -5,4 +5,4 @@ package internal // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/ot
 
 // Version is the current release version of the OpenTelemetry OTLP HTTP trace
 // exporter in use.
-const Version = "1.39.0"
+const Version = "1.42.0"
diff --git a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go
index 6838f3c4e3fa9..d1b43c3ba43f0 100644
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/version.go
@@ -5,5 +5,5 @@ package otlptrace // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
 
 // Version is the current release version of the OpenTelemetry OTLP trace exporter in use.
 func Version() string {
-	return "1.39.0"
+	return "1.42.0"
 }
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/otelconv/metric.go b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/otelconv/metric.go
deleted file mode 100644
index fd064530c34c3..0000000000000
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/otelconv/metric.go
+++ /dev/null
@@ -1,2264 +0,0 @@
-// Code generated from semantic convention specification. DO NOT EDIT.
-
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-// Package otelconv provides types and functionality for OpenTelemetry semantic
-// conventions in the "otel" namespace.
-package otelconv
-
-import (
-	"context"
-	"sync"
-
-	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/metric/noop"
-)
-
-var (
-	addOptPool = &sync.Pool{New: func() any { return &[]metric.AddOption{} }}
-	recOptPool = &sync.Pool{New: func() any { return &[]metric.RecordOption{} }}
-)
-
-// ErrorTypeAttr is an attribute conforming to the error.type semantic
-// conventions. It represents the describes a class of error the operation ended
-// with.
-type ErrorTypeAttr string
-
-var (
-	// ErrorTypeOther is a fallback error value to be used when the instrumentation
-	// doesn't define a custom value.
-	ErrorTypeOther ErrorTypeAttr = "_OTHER"
-)
-
-// ComponentTypeAttr is an attribute conforming to the otel.component.type
-// semantic conventions. It represents a name identifying the type of the
-// OpenTelemetry component.
-type ComponentTypeAttr string
-
-var (
-	// ComponentTypeBatchingSpanProcessor is the builtin SDK batching span
-	// processor.
-	ComponentTypeBatchingSpanProcessor ComponentTypeAttr = "batching_span_processor"
-	// ComponentTypeSimpleSpanProcessor is the builtin SDK simple span processor.
-	ComponentTypeSimpleSpanProcessor ComponentTypeAttr = "simple_span_processor"
-	// ComponentTypeBatchingLogProcessor is the builtin SDK batching log record
-	// processor.
-	ComponentTypeBatchingLogProcessor ComponentTypeAttr = "batching_log_processor"
-	// ComponentTypeSimpleLogProcessor is the builtin SDK simple log record
-	// processor.
-	ComponentTypeSimpleLogProcessor ComponentTypeAttr = "simple_log_processor"
-	// ComponentTypeOtlpGRPCSpanExporter is the OTLP span exporter over gRPC with
-	// protobuf serialization.
-	ComponentTypeOtlpGRPCSpanExporter ComponentTypeAttr = "otlp_grpc_span_exporter"
-	// ComponentTypeOtlpHTTPSpanExporter is the OTLP span exporter over HTTP with
-	// protobuf serialization.
-	ComponentTypeOtlpHTTPSpanExporter ComponentTypeAttr = "otlp_http_span_exporter"
-	// ComponentTypeOtlpHTTPJSONSpanExporter is the OTLP span exporter over HTTP
-	// with JSON serialization.
-	ComponentTypeOtlpHTTPJSONSpanExporter ComponentTypeAttr = "otlp_http_json_span_exporter"
-	// ComponentTypeZipkinHTTPSpanExporter is the zipkin span exporter over HTTP.
-	ComponentTypeZipkinHTTPSpanExporter ComponentTypeAttr = "zipkin_http_span_exporter"
-	// ComponentTypeOtlpGRPCLogExporter is the OTLP log record exporter over gRPC
-	// with protobuf serialization.
-	ComponentTypeOtlpGRPCLogExporter ComponentTypeAttr = "otlp_grpc_log_exporter"
-	// ComponentTypeOtlpHTTPLogExporter is the OTLP log record exporter over HTTP
-	// with protobuf serialization.
-	ComponentTypeOtlpHTTPLogExporter ComponentTypeAttr = "otlp_http_log_exporter"
-	// ComponentTypeOtlpHTTPJSONLogExporter is the OTLP log record exporter over
-	// HTTP with JSON serialization.
-	ComponentTypeOtlpHTTPJSONLogExporter ComponentTypeAttr = "otlp_http_json_log_exporter"
-	// ComponentTypePeriodicMetricReader is the builtin SDK periodically exporting
-	// metric reader.
-	ComponentTypePeriodicMetricReader ComponentTypeAttr = "periodic_metric_reader"
-	// ComponentTypeOtlpGRPCMetricExporter is the OTLP metric exporter over gRPC
-	// with protobuf serialization.
-	ComponentTypeOtlpGRPCMetricExporter ComponentTypeAttr = "otlp_grpc_metric_exporter"
-	// ComponentTypeOtlpHTTPMetricExporter is the OTLP metric exporter over HTTP
-	// with protobuf serialization.
-	ComponentTypeOtlpHTTPMetricExporter ComponentTypeAttr = "otlp_http_metric_exporter"
-	// ComponentTypeOtlpHTTPJSONMetricExporter is the OTLP metric exporter over HTTP
-	// with JSON serialization.
-	ComponentTypeOtlpHTTPJSONMetricExporter ComponentTypeAttr = "otlp_http_json_metric_exporter"
-	// ComponentTypePrometheusHTTPTextMetricExporter is the prometheus metric
-	// exporter over HTTP with the default text-based format.
-	ComponentTypePrometheusHTTPTextMetricExporter ComponentTypeAttr = "prometheus_http_text_metric_exporter"
-)
-
-// SpanParentOriginAttr is an attribute conforming to the otel.span.parent.origin
-// semantic conventions. It represents the determines whether the span has a
-// parent span, and if so, [whether it is a remote parent].
-//
-// [whether it is a remote parent]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote
-type SpanParentOriginAttr string
-
-var (
-	// SpanParentOriginNone is the span does not have a parent, it is a root span.
-	SpanParentOriginNone SpanParentOriginAttr = "none"
-	// SpanParentOriginLocal is the span has a parent and the parent's span context
-	// [isRemote()] is false.
-	//
-	// [isRemote()]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote
-	SpanParentOriginLocal SpanParentOriginAttr = "local"
-	// SpanParentOriginRemote is the span has a parent and the parent's span context
-	// [isRemote()] is true.
-	//
-	// [isRemote()]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote
-	SpanParentOriginRemote SpanParentOriginAttr = "remote"
-)
-
-// SpanSamplingResultAttr is an attribute conforming to the
-// otel.span.sampling_result semantic conventions. It represents the result value
-// of the sampler for this span.
-type SpanSamplingResultAttr string
-
-var (
-	// SpanSamplingResultDrop is the span is not sampled and not recording.
-	SpanSamplingResultDrop SpanSamplingResultAttr = "DROP"
-	// SpanSamplingResultRecordOnly is the span is not sampled, but recording.
-	SpanSamplingResultRecordOnly SpanSamplingResultAttr = "RECORD_ONLY"
-	// SpanSamplingResultRecordAndSample is the span is sampled and recording.
-	SpanSamplingResultRecordAndSample SpanSamplingResultAttr = "RECORD_AND_SAMPLE"
-)
-
-// RPCGRPCStatusCodeAttr is an attribute conforming to the rpc.grpc.status_code
-// semantic conventions. It represents the gRPC status code of the last gRPC
-// requests performed in scope of this export call.
-type RPCGRPCStatusCodeAttr int64
-
-var (
-	// RPCGRPCStatusCodeOk is the OK.
-	RPCGRPCStatusCodeOk RPCGRPCStatusCodeAttr = 0
-	// RPCGRPCStatusCodeCancelled is the CANCELLED.
-	RPCGRPCStatusCodeCancelled RPCGRPCStatusCodeAttr = 1
-	// RPCGRPCStatusCodeUnknown is the UNKNOWN.
-	RPCGRPCStatusCodeUnknown RPCGRPCStatusCodeAttr = 2
-	// RPCGRPCStatusCodeInvalidArgument is the INVALID_ARGUMENT.
-	RPCGRPCStatusCodeInvalidArgument RPCGRPCStatusCodeAttr = 3
-	// RPCGRPCStatusCodeDeadlineExceeded is the DEADLINE_EXCEEDED.
-	RPCGRPCStatusCodeDeadlineExceeded RPCGRPCStatusCodeAttr = 4
-	// RPCGRPCStatusCodeNotFound is the NOT_FOUND.
-	RPCGRPCStatusCodeNotFound RPCGRPCStatusCodeAttr = 5
-	// RPCGRPCStatusCodeAlreadyExists is the ALREADY_EXISTS.
-	RPCGRPCStatusCodeAlreadyExists RPCGRPCStatusCodeAttr = 6
-	// RPCGRPCStatusCodePermissionDenied is the PERMISSION_DENIED.
-	RPCGRPCStatusCodePermissionDenied RPCGRPCStatusCodeAttr = 7
-	// RPCGRPCStatusCodeResourceExhausted is the RESOURCE_EXHAUSTED.
-	RPCGRPCStatusCodeResourceExhausted RPCGRPCStatusCodeAttr = 8
-	// RPCGRPCStatusCodeFailedPrecondition is the FAILED_PRECONDITION.
-	RPCGRPCStatusCodeFailedPrecondition RPCGRPCStatusCodeAttr = 9
-	// RPCGRPCStatusCodeAborted is the ABORTED.
-	RPCGRPCStatusCodeAborted RPCGRPCStatusCodeAttr = 10
-	// RPCGRPCStatusCodeOutOfRange is the OUT_OF_RANGE.
-	RPCGRPCStatusCodeOutOfRange RPCGRPCStatusCodeAttr = 11
-	// RPCGRPCStatusCodeUnimplemented is the UNIMPLEMENTED.
-	RPCGRPCStatusCodeUnimplemented RPCGRPCStatusCodeAttr = 12
-	// RPCGRPCStatusCodeInternal is the INTERNAL.
-	RPCGRPCStatusCodeInternal RPCGRPCStatusCodeAttr = 13
-	// RPCGRPCStatusCodeUnavailable is the UNAVAILABLE.
-	RPCGRPCStatusCodeUnavailable RPCGRPCStatusCodeAttr = 14
-	// RPCGRPCStatusCodeDataLoss is the DATA_LOSS.
-	RPCGRPCStatusCodeDataLoss RPCGRPCStatusCodeAttr = 15
-	// RPCGRPCStatusCodeUnauthenticated is the UNAUTHENTICATED.
-	RPCGRPCStatusCodeUnauthenticated RPCGRPCStatusCodeAttr = 16
-)
-
-// SDKExporterLogExported is an instrument used to record metric values
-// conforming to the "otel.sdk.exporter.log.exported" semantic conventions. It
-// represents the number of log records for which the export has finished, either
-// successful or failed.
-type SDKExporterLogExported struct {
-	metric.Int64Counter
-}
-
-var newSDKExporterLogExportedOpts = []metric.Int64CounterOption{
-	metric.WithDescription("The number of log records for which the export has finished, either successful or failed."),
-	metric.WithUnit("{log_record}"),
-}
-
-// NewSDKExporterLogExported returns a new SDKExporterLogExported instrument.
-func NewSDKExporterLogExported(
-	m metric.Meter,
-	opt ...metric.Int64CounterOption,
-) (SDKExporterLogExported, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKExporterLogExported{noop.Int64Counter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKExporterLogExportedOpts
-	} else {
-		opt = append(opt, newSDKExporterLogExportedOpts...)
-	}
-
-	i, err := m.Int64Counter(
-		"otel.sdk.exporter.log.exported",
-		opt...,
-	)
-	if err != nil {
-		return SDKExporterLogExported{noop.Int64Counter{}}, err
-	}
-	return SDKExporterLogExported{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKExporterLogExported) Inst() metric.Int64Counter {
-	return m.Int64Counter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKExporterLogExported) Name() string {
-	return "otel.sdk.exporter.log.exported"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKExporterLogExported) Unit() string {
-	return "{log_record}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKExporterLogExported) Description() string {
-	return "The number of log records for which the export has finished, either successful or failed."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-// For exporters with partial success semantics (e.g. OTLP with
-// `rejected_log_records`), rejected log records MUST count as failed and only
-// non-rejected log records count as success.
-// If no rejection reason is available, `rejected` SHOULD be used as value for
-// `error.type`.
-func (m SDKExporterLogExported) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-// For exporters with partial success semantics (e.g. OTLP with
-// `rejected_log_records`), rejected log records MUST count as failed and only
-// non-rejected log records count as success.
-// If no rejection reason is available, `rejected` SHOULD be used as value for
-// `error.type`.
-func (m SDKExporterLogExported) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AttrErrorType returns an optional attribute for the "error.type" semantic
-// convention. It represents the describes a class of error the operation ended
-// with.
-func (SDKExporterLogExported) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
-	return attribute.String("error.type", string(val))
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKExporterLogExported) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKExporterLogExported) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// AttrServerAddress returns an optional attribute for the "server.address"
-// semantic convention. It represents the server domain name if available without
-// reverse DNS lookup; otherwise, IP address or Unix domain socket name.
-func (SDKExporterLogExported) AttrServerAddress(val string) attribute.KeyValue {
-	return attribute.String("server.address", val)
-}
-
-// AttrServerPort returns an optional attribute for the "server.port" semantic
-// convention. It represents the server port number.
-func (SDKExporterLogExported) AttrServerPort(val int) attribute.KeyValue {
-	return attribute.Int("server.port", val)
-}
-
-// SDKExporterLogInflight is an instrument used to record metric values
-// conforming to the "otel.sdk.exporter.log.inflight" semantic conventions. It
-// represents the number of log records which were passed to the exporter, but
-// that have not been exported yet (neither successful, nor failed).
-type SDKExporterLogInflight struct {
-	metric.Int64UpDownCounter
-}
-
-var newSDKExporterLogInflightOpts = []metric.Int64UpDownCounterOption{
-	metric.WithDescription("The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."),
-	metric.WithUnit("{log_record}"),
-}
-
-// NewSDKExporterLogInflight returns a new SDKExporterLogInflight instrument.
-func NewSDKExporterLogInflight(
-	m metric.Meter,
-	opt ...metric.Int64UpDownCounterOption,
-) (SDKExporterLogInflight, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKExporterLogInflight{noop.Int64UpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKExporterLogInflightOpts
-	} else {
-		opt = append(opt, newSDKExporterLogInflightOpts...)
-	}
-
-	i, err := m.Int64UpDownCounter(
-		"otel.sdk.exporter.log.inflight",
-		opt...,
-	)
-	if err != nil {
-		return SDKExporterLogInflight{noop.Int64UpDownCounter{}}, err
-	}
-	return SDKExporterLogInflight{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKExporterLogInflight) Inst() metric.Int64UpDownCounter {
-	return m.Int64UpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKExporterLogInflight) Name() string {
-	return "otel.sdk.exporter.log.inflight"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKExporterLogInflight) Unit() string {
-	return "{log_record}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKExporterLogInflight) Description() string {
-	return "The number of log records which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-func (m SDKExporterLogInflight) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-func (m SDKExporterLogInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKExporterLogInflight) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKExporterLogInflight) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// AttrServerAddress returns an optional attribute for the "server.address"
-// semantic convention. It represents the server domain name if available without
-// reverse DNS lookup; otherwise, IP address or Unix domain socket name.
-func (SDKExporterLogInflight) AttrServerAddress(val string) attribute.KeyValue {
-	return attribute.String("server.address", val)
-}
-
-// AttrServerPort returns an optional attribute for the "server.port" semantic
-// convention. It represents the server port number.
-func (SDKExporterLogInflight) AttrServerPort(val int) attribute.KeyValue {
-	return attribute.Int("server.port", val)
-}
-
-// SDKExporterMetricDataPointExported is an instrument used to record metric
-// values conforming to the "otel.sdk.exporter.metric_data_point.exported"
-// semantic conventions. It represents the number of metric data points for which
-// the export has finished, either successful or failed.
-type SDKExporterMetricDataPointExported struct {
-	metric.Int64Counter
-}
-
-var newSDKExporterMetricDataPointExportedOpts = []metric.Int64CounterOption{
-	metric.WithDescription("The number of metric data points for which the export has finished, either successful or failed."),
-	metric.WithUnit("{data_point}"),
-}
-
-// NewSDKExporterMetricDataPointExported returns a new
-// SDKExporterMetricDataPointExported instrument.
-func NewSDKExporterMetricDataPointExported(
-	m metric.Meter,
-	opt ...metric.Int64CounterOption,
-) (SDKExporterMetricDataPointExported, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKExporterMetricDataPointExported{noop.Int64Counter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKExporterMetricDataPointExportedOpts
-	} else {
-		opt = append(opt, newSDKExporterMetricDataPointExportedOpts...)
-	}
-
-	i, err := m.Int64Counter(
-		"otel.sdk.exporter.metric_data_point.exported",
-		opt...,
-	)
-	if err != nil {
-		return SDKExporterMetricDataPointExported{noop.Int64Counter{}}, err
-	}
-	return SDKExporterMetricDataPointExported{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKExporterMetricDataPointExported) Inst() metric.Int64Counter {
-	return m.Int64Counter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKExporterMetricDataPointExported) Name() string {
-	return "otel.sdk.exporter.metric_data_point.exported"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKExporterMetricDataPointExported) Unit() string {
-	return "{data_point}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKExporterMetricDataPointExported) Description() string {
-	return "The number of metric data points for which the export has finished, either successful or failed."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-// For exporters with partial success semantics (e.g. OTLP with
-// `rejected_data_points`), rejected data points MUST count as failed and only
-// non-rejected data points count as success.
-// If no rejection reason is available, `rejected` SHOULD be used as value for
-// `error.type`.
-func (m SDKExporterMetricDataPointExported) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-// For exporters with partial success semantics (e.g. OTLP with
-// `rejected_data_points`), rejected data points MUST count as failed and only
-// non-rejected data points count as success.
-// If no rejection reason is available, `rejected` SHOULD be used as value for
-// `error.type`.
-func (m SDKExporterMetricDataPointExported) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AttrErrorType returns an optional attribute for the "error.type" semantic
-// convention. It represents the describes a class of error the operation ended
-// with.
-func (SDKExporterMetricDataPointExported) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
-	return attribute.String("error.type", string(val))
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKExporterMetricDataPointExported) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKExporterMetricDataPointExported) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// AttrServerAddress returns an optional attribute for the "server.address"
-// semantic convention. It represents the server domain name if available without
-// reverse DNS lookup; otherwise, IP address or Unix domain socket name.
-func (SDKExporterMetricDataPointExported) AttrServerAddress(val string) attribute.KeyValue {
-	return attribute.String("server.address", val)
-}
-
-// AttrServerPort returns an optional attribute for the "server.port" semantic
-// convention. It represents the server port number.
-func (SDKExporterMetricDataPointExported) AttrServerPort(val int) attribute.KeyValue {
-	return attribute.Int("server.port", val)
-}
-
-// SDKExporterMetricDataPointInflight is an instrument used to record metric
-// values conforming to the "otel.sdk.exporter.metric_data_point.inflight"
-// semantic conventions. It represents the number of metric data points which
-// were passed to the exporter, but that have not been exported yet (neither
-// successful, nor failed).
-type SDKExporterMetricDataPointInflight struct {
-	metric.Int64UpDownCounter
-}
-
-var newSDKExporterMetricDataPointInflightOpts = []metric.Int64UpDownCounterOption{
-	metric.WithDescription("The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."),
-	metric.WithUnit("{data_point}"),
-}
-
-// NewSDKExporterMetricDataPointInflight returns a new
-// SDKExporterMetricDataPointInflight instrument.
-func NewSDKExporterMetricDataPointInflight(
-	m metric.Meter,
-	opt ...metric.Int64UpDownCounterOption,
-) (SDKExporterMetricDataPointInflight, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKExporterMetricDataPointInflight{noop.Int64UpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKExporterMetricDataPointInflightOpts
-	} else {
-		opt = append(opt, newSDKExporterMetricDataPointInflightOpts...)
-	}
-
-	i, err := m.Int64UpDownCounter(
-		"otel.sdk.exporter.metric_data_point.inflight",
-		opt...,
-	)
-	if err != nil {
-		return SDKExporterMetricDataPointInflight{noop.Int64UpDownCounter{}}, err
-	}
-	return SDKExporterMetricDataPointInflight{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKExporterMetricDataPointInflight) Inst() metric.Int64UpDownCounter {
-	return m.Int64UpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKExporterMetricDataPointInflight) Name() string {
-	return "otel.sdk.exporter.metric_data_point.inflight"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKExporterMetricDataPointInflight) Unit() string {
-	return "{data_point}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKExporterMetricDataPointInflight) Description() string {
-	return "The number of metric data points which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-func (m SDKExporterMetricDataPointInflight) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-func (m SDKExporterMetricDataPointInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKExporterMetricDataPointInflight) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKExporterMetricDataPointInflight) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// AttrServerAddress returns an optional attribute for the "server.address"
-// semantic convention. It represents the server domain name if available without
-// reverse DNS lookup; otherwise, IP address or Unix domain socket name.
-func (SDKExporterMetricDataPointInflight) AttrServerAddress(val string) attribute.KeyValue {
-	return attribute.String("server.address", val)
-}
-
-// AttrServerPort returns an optional attribute for the "server.port" semantic
-// convention. It represents the server port number.
-func (SDKExporterMetricDataPointInflight) AttrServerPort(val int) attribute.KeyValue {
-	return attribute.Int("server.port", val)
-}
-
-// SDKExporterOperationDuration is an instrument used to record metric values
-// conforming to the "otel.sdk.exporter.operation.duration" semantic conventions.
-// It represents the duration of exporting a batch of telemetry records.
-type SDKExporterOperationDuration struct {
-	metric.Float64Histogram
-}
-
-var newSDKExporterOperationDurationOpts = []metric.Float64HistogramOption{
-	metric.WithDescription("The duration of exporting a batch of telemetry records."),
-	metric.WithUnit("s"),
-}
-
-// NewSDKExporterOperationDuration returns a new SDKExporterOperationDuration
-// instrument.
-func NewSDKExporterOperationDuration(
-	m metric.Meter,
-	opt ...metric.Float64HistogramOption,
-) (SDKExporterOperationDuration, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKExporterOperationDuration{noop.Float64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKExporterOperationDurationOpts
-	} else {
-		opt = append(opt, newSDKExporterOperationDurationOpts...)
-	}
-
-	i, err := m.Float64Histogram(
-		"otel.sdk.exporter.operation.duration",
-		opt...,
-	)
-	if err != nil {
-		return SDKExporterOperationDuration{noop.Float64Histogram{}}, err
-	}
-	return SDKExporterOperationDuration{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKExporterOperationDuration) Inst() metric.Float64Histogram {
-	return m.Float64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKExporterOperationDuration) Name() string {
-	return "otel.sdk.exporter.operation.duration"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKExporterOperationDuration) Unit() string {
-	return "s"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKExporterOperationDuration) Description() string {
-	return "The duration of exporting a batch of telemetry records."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// This metric defines successful operations using the full success definitions
-// for [http]
-// and [grpc]. Anything else is defined as an unsuccessful operation. For
-// successful
-// operations, `error.type` MUST NOT be set. For unsuccessful export operations,
-// `error.type` MUST contain a relevant failure cause.
-//
-// [http]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1
-// [grpc]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success
-func (m SDKExporterOperationDuration) Record(
-	ctx context.Context,
-	val float64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// This metric defines successful operations using the full success definitions
-// for [http]
-// and [grpc]. Anything else is defined as an unsuccessful operation. For
-// successful
-// operations, `error.type` MUST NOT be set. For unsuccessful export operations,
-// `error.type` MUST contain a relevant failure cause.
-//
-// [http]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success-1
-// [grpc]: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.5.0/docs/specification.md#full-success
-func (m SDKExporterOperationDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// AttrErrorType returns an optional attribute for the "error.type" semantic
-// convention. It represents the describes a class of error the operation ended
-// with.
-func (SDKExporterOperationDuration) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
-	return attribute.String("error.type", string(val))
-}
-
-// AttrHTTPResponseStatusCode returns an optional attribute for the
-// "http.response.status_code" semantic convention. It represents the HTTP status
-// code of the last HTTP request performed in scope of this export call.
-func (SDKExporterOperationDuration) AttrHTTPResponseStatusCode(val int) attribute.KeyValue {
-	return attribute.Int("http.response.status_code", val)
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKExporterOperationDuration) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKExporterOperationDuration) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// AttrRPCGRPCStatusCode returns an optional attribute for the
-// "rpc.grpc.status_code" semantic convention. It represents the gRPC status code
-// of the last gRPC requests performed in scope of this export call.
-func (SDKExporterOperationDuration) AttrRPCGRPCStatusCode(val RPCGRPCStatusCodeAttr) attribute.KeyValue {
-	return attribute.Int64("rpc.grpc.status_code", int64(val))
-}
-
-// AttrServerAddress returns an optional attribute for the "server.address"
-// semantic convention. It represents the server domain name if available without
-// reverse DNS lookup; otherwise, IP address or Unix domain socket name.
-func (SDKExporterOperationDuration) AttrServerAddress(val string) attribute.KeyValue {
-	return attribute.String("server.address", val)
-}
-
-// AttrServerPort returns an optional attribute for the "server.port" semantic
-// convention. It represents the server port number.
-func (SDKExporterOperationDuration) AttrServerPort(val int) attribute.KeyValue {
-	return attribute.Int("server.port", val)
-}
-
-// SDKExporterSpanExported is an instrument used to record metric values
-// conforming to the "otel.sdk.exporter.span.exported" semantic conventions. It
-// represents the number of spans for which the export has finished, either
-// successful or failed.
-type SDKExporterSpanExported struct {
-	metric.Int64Counter
-}
-
-var newSDKExporterSpanExportedOpts = []metric.Int64CounterOption{
-	metric.WithDescription("The number of spans for which the export has finished, either successful or failed."),
-	metric.WithUnit("{span}"),
-}
-
-// NewSDKExporterSpanExported returns a new SDKExporterSpanExported instrument.
-func NewSDKExporterSpanExported(
-	m metric.Meter,
-	opt ...metric.Int64CounterOption,
-) (SDKExporterSpanExported, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKExporterSpanExported{noop.Int64Counter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKExporterSpanExportedOpts
-	} else {
-		opt = append(opt, newSDKExporterSpanExportedOpts...)
-	}
-
-	i, err := m.Int64Counter(
-		"otel.sdk.exporter.span.exported",
-		opt...,
-	)
-	if err != nil {
-		return SDKExporterSpanExported{noop.Int64Counter{}}, err
-	}
-	return SDKExporterSpanExported{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKExporterSpanExported) Inst() metric.Int64Counter {
-	return m.Int64Counter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKExporterSpanExported) Name() string {
-	return "otel.sdk.exporter.span.exported"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKExporterSpanExported) Unit() string {
-	return "{span}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKExporterSpanExported) Description() string {
-	return "The number of spans for which the export has finished, either successful or failed."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-// For exporters with partial success semantics (e.g. OTLP with `rejected_spans`
-// ), rejected spans MUST count as failed and only non-rejected spans count as
-// success.
-// If no rejection reason is available, `rejected` SHOULD be used as value for
-// `error.type`.
-func (m SDKExporterSpanExported) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-// For exporters with partial success semantics (e.g. OTLP with `rejected_spans`
-// ), rejected spans MUST count as failed and only non-rejected spans count as
-// success.
-// If no rejection reason is available, `rejected` SHOULD be used as value for
-// `error.type`.
-func (m SDKExporterSpanExported) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AttrErrorType returns an optional attribute for the "error.type" semantic
-// convention. It represents the describes a class of error the operation ended
-// with.
-func (SDKExporterSpanExported) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
-	return attribute.String("error.type", string(val))
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKExporterSpanExported) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKExporterSpanExported) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// AttrServerAddress returns an optional attribute for the "server.address"
-// semantic convention. It represents the server domain name if available without
-// reverse DNS lookup; otherwise, IP address or Unix domain socket name.
-func (SDKExporterSpanExported) AttrServerAddress(val string) attribute.KeyValue {
-	return attribute.String("server.address", val)
-}
-
-// AttrServerPort returns an optional attribute for the "server.port" semantic
-// convention. It represents the server port number.
-func (SDKExporterSpanExported) AttrServerPort(val int) attribute.KeyValue {
-	return attribute.Int("server.port", val)
-}
-
-// SDKExporterSpanInflight is an instrument used to record metric values
-// conforming to the "otel.sdk.exporter.span.inflight" semantic conventions. It
-// represents the number of spans which were passed to the exporter, but that
-// have not been exported yet (neither successful, nor failed).
-type SDKExporterSpanInflight struct {
-	metric.Int64UpDownCounter
-}
-
-var newSDKExporterSpanInflightOpts = []metric.Int64UpDownCounterOption{
-	metric.WithDescription("The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."),
-	metric.WithUnit("{span}"),
-}
-
-// NewSDKExporterSpanInflight returns a new SDKExporterSpanInflight instrument.
-func NewSDKExporterSpanInflight(
-	m metric.Meter,
-	opt ...metric.Int64UpDownCounterOption,
-) (SDKExporterSpanInflight, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKExporterSpanInflight{noop.Int64UpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKExporterSpanInflightOpts
-	} else {
-		opt = append(opt, newSDKExporterSpanInflightOpts...)
-	}
-
-	i, err := m.Int64UpDownCounter(
-		"otel.sdk.exporter.span.inflight",
-		opt...,
-	)
-	if err != nil {
-		return SDKExporterSpanInflight{noop.Int64UpDownCounter{}}, err
-	}
-	return SDKExporterSpanInflight{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKExporterSpanInflight) Inst() metric.Int64UpDownCounter {
-	return m.Int64UpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKExporterSpanInflight) Name() string {
-	return "otel.sdk.exporter.span.inflight"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKExporterSpanInflight) Unit() string {
-	return "{span}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKExporterSpanInflight) Description() string {
-	return "The number of spans which were passed to the exporter, but that have not been exported yet (neither successful, nor failed)."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-func (m SDKExporterSpanInflight) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful exports, `error.type` MUST NOT be set. For failed exports,
-// `error.type` MUST contain the failure cause.
-func (m SDKExporterSpanInflight) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKExporterSpanInflight) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKExporterSpanInflight) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// AttrServerAddress returns an optional attribute for the "server.address"
-// semantic convention. It represents the server domain name if available without
-// reverse DNS lookup; otherwise, IP address or Unix domain socket name.
-func (SDKExporterSpanInflight) AttrServerAddress(val string) attribute.KeyValue {
-	return attribute.String("server.address", val)
-}
-
-// AttrServerPort returns an optional attribute for the "server.port" semantic
-// convention. It represents the server port number.
-func (SDKExporterSpanInflight) AttrServerPort(val int) attribute.KeyValue {
-	return attribute.Int("server.port", val)
-}
-
-// SDKLogCreated is an instrument used to record metric values conforming to the
-// "otel.sdk.log.created" semantic conventions. It represents the number of logs
-// submitted to enabled SDK Loggers.
-type SDKLogCreated struct {
-	metric.Int64Counter
-}
-
-var newSDKLogCreatedOpts = []metric.Int64CounterOption{
-	metric.WithDescription("The number of logs submitted to enabled SDK Loggers."),
-	metric.WithUnit("{log_record}"),
-}
-
-// NewSDKLogCreated returns a new SDKLogCreated instrument.
-func NewSDKLogCreated(
-	m metric.Meter,
-	opt ...metric.Int64CounterOption,
-) (SDKLogCreated, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKLogCreated{noop.Int64Counter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKLogCreatedOpts
-	} else {
-		opt = append(opt, newSDKLogCreatedOpts...)
-	}
-
-	i, err := m.Int64Counter(
-		"otel.sdk.log.created",
-		opt...,
-	)
-	if err != nil {
-		return SDKLogCreated{noop.Int64Counter{}}, err
-	}
-	return SDKLogCreated{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKLogCreated) Inst() metric.Int64Counter {
-	return m.Int64Counter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKLogCreated) Name() string {
-	return "otel.sdk.log.created"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKLogCreated) Unit() string {
-	return "{log_record}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKLogCreated) Description() string {
-	return "The number of logs submitted to enabled SDK Loggers."
-}
-
-// Add adds incr to the existing count for attrs.
-func (m SDKLogCreated) Add(ctx context.Context, incr int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-func (m SDKLogCreated) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// SDKMetricReaderCollectionDuration is an instrument used to record metric
-// values conforming to the "otel.sdk.metric_reader.collection.duration" semantic
-// conventions. It represents the duration of the collect operation of the metric
-// reader.
-type SDKMetricReaderCollectionDuration struct {
-	metric.Float64Histogram
-}
-
-var newSDKMetricReaderCollectionDurationOpts = []metric.Float64HistogramOption{
-	metric.WithDescription("The duration of the collect operation of the metric reader."),
-	metric.WithUnit("s"),
-}
-
-// NewSDKMetricReaderCollectionDuration returns a new
-// SDKMetricReaderCollectionDuration instrument.
-func NewSDKMetricReaderCollectionDuration(
-	m metric.Meter,
-	opt ...metric.Float64HistogramOption,
-) (SDKMetricReaderCollectionDuration, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKMetricReaderCollectionDuration{noop.Float64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKMetricReaderCollectionDurationOpts
-	} else {
-		opt = append(opt, newSDKMetricReaderCollectionDurationOpts...)
-	}
-
-	i, err := m.Float64Histogram(
-		"otel.sdk.metric_reader.collection.duration",
-		opt...,
-	)
-	if err != nil {
-		return SDKMetricReaderCollectionDuration{noop.Float64Histogram{}}, err
-	}
-	return SDKMetricReaderCollectionDuration{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKMetricReaderCollectionDuration) Inst() metric.Float64Histogram {
-	return m.Float64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKMetricReaderCollectionDuration) Name() string {
-	return "otel.sdk.metric_reader.collection.duration"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKMetricReaderCollectionDuration) Unit() string {
-	return "s"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKMetricReaderCollectionDuration) Description() string {
-	return "The duration of the collect operation of the metric reader."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful collections, `error.type` MUST NOT be set. For failed
-// collections, `error.type` SHOULD contain the failure cause.
-// It can happen that metrics collection is successful for some MetricProducers,
-// while others fail. In that case `error.type` SHOULD be set to any of the
-// failure causes.
-func (m SDKMetricReaderCollectionDuration) Record(
-	ctx context.Context,
-	val float64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// For successful collections, `error.type` MUST NOT be set. For failed
-// collections, `error.type` SHOULD contain the failure cause.
-// It can happen that metrics collection is successful for some MetricProducers,
-// while others fail. In that case `error.type` SHOULD be set to any of the
-// failure causes.
-func (m SDKMetricReaderCollectionDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// AttrErrorType returns an optional attribute for the "error.type" semantic
-// convention. It represents the describes a class of error the operation ended
-// with.
-func (SDKMetricReaderCollectionDuration) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
-	return attribute.String("error.type", string(val))
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKMetricReaderCollectionDuration) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKMetricReaderCollectionDuration) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// SDKProcessorLogProcessed is an instrument used to record metric values
-// conforming to the "otel.sdk.processor.log.processed" semantic conventions. It
-// represents the number of log records for which the processing has finished,
-// either successful or failed.
-type SDKProcessorLogProcessed struct {
-	metric.Int64Counter
-}
-
-var newSDKProcessorLogProcessedOpts = []metric.Int64CounterOption{
-	metric.WithDescription("The number of log records for which the processing has finished, either successful or failed."),
-	metric.WithUnit("{log_record}"),
-}
-
-// NewSDKProcessorLogProcessed returns a new SDKProcessorLogProcessed instrument.
-func NewSDKProcessorLogProcessed(
-	m metric.Meter,
-	opt ...metric.Int64CounterOption,
-) (SDKProcessorLogProcessed, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKProcessorLogProcessed{noop.Int64Counter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKProcessorLogProcessedOpts
-	} else {
-		opt = append(opt, newSDKProcessorLogProcessedOpts...)
-	}
-
-	i, err := m.Int64Counter(
-		"otel.sdk.processor.log.processed",
-		opt...,
-	)
-	if err != nil {
-		return SDKProcessorLogProcessed{noop.Int64Counter{}}, err
-	}
-	return SDKProcessorLogProcessed{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKProcessorLogProcessed) Inst() metric.Int64Counter {
-	return m.Int64Counter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKProcessorLogProcessed) Name() string {
-	return "otel.sdk.processor.log.processed"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKProcessorLogProcessed) Unit() string {
-	return "{log_record}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKProcessorLogProcessed) Description() string {
-	return "The number of log records for which the processing has finished, either successful or failed."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful processing, `error.type` MUST NOT be set. For failed
-// processing, `error.type` MUST contain the failure cause.
-// For the SDK Simple and Batching Log Record Processor a log record is
-// considered to be processed already when it has been submitted to the exporter,
-// not when the corresponding export call has finished.
-func (m SDKProcessorLogProcessed) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful processing, `error.type` MUST NOT be set. For failed
-// processing, `error.type` MUST contain the failure cause.
-// For the SDK Simple and Batching Log Record Processor a log record is
-// considered to be processed already when it has been submitted to the exporter,
-// not when the corresponding export call has finished.
-func (m SDKProcessorLogProcessed) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AttrErrorType returns an optional attribute for the "error.type" semantic
-// convention. It represents a low-cardinality description of the failure reason.
-// SDK Batching Log Record Processors MUST use `queue_full` for log records
-// dropped due to a full queue.
-func (SDKProcessorLogProcessed) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
-	return attribute.String("error.type", string(val))
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKProcessorLogProcessed) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKProcessorLogProcessed) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// SDKProcessorLogQueueCapacity is an instrument used to record metric values
-// conforming to the "otel.sdk.processor.log.queue.capacity" semantic
-// conventions. It represents the maximum number of log records the queue of a
-// given instance of an SDK Log Record processor can hold.
-type SDKProcessorLogQueueCapacity struct {
-	metric.Int64ObservableUpDownCounter
-}
-
-var newSDKProcessorLogQueueCapacityOpts = []metric.Int64ObservableUpDownCounterOption{
-	metric.WithDescription("The maximum number of log records the queue of a given instance of an SDK Log Record processor can hold."),
-	metric.WithUnit("{log_record}"),
-}
-
-// NewSDKProcessorLogQueueCapacity returns a new SDKProcessorLogQueueCapacity
-// instrument.
-func NewSDKProcessorLogQueueCapacity(
-	m metric.Meter,
-	opt ...metric.Int64ObservableUpDownCounterOption,
-) (SDKProcessorLogQueueCapacity, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKProcessorLogQueueCapacity{noop.Int64ObservableUpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKProcessorLogQueueCapacityOpts
-	} else {
-		opt = append(opt, newSDKProcessorLogQueueCapacityOpts...)
-	}
-
-	i, err := m.Int64ObservableUpDownCounter(
-		"otel.sdk.processor.log.queue.capacity",
-		opt...,
-	)
-	if err != nil {
-		return SDKProcessorLogQueueCapacity{noop.Int64ObservableUpDownCounter{}}, err
-	}
-	return SDKProcessorLogQueueCapacity{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKProcessorLogQueueCapacity) Inst() metric.Int64ObservableUpDownCounter {
-	return m.Int64ObservableUpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKProcessorLogQueueCapacity) Name() string {
-	return "otel.sdk.processor.log.queue.capacity"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKProcessorLogQueueCapacity) Unit() string {
-	return "{log_record}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKProcessorLogQueueCapacity) Description() string {
-	return "The maximum number of log records the queue of a given instance of an SDK Log Record processor can hold."
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKProcessorLogQueueCapacity) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKProcessorLogQueueCapacity) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// SDKProcessorLogQueueSize is an instrument used to record metric values
-// conforming to the "otel.sdk.processor.log.queue.size" semantic conventions. It
-// represents the number of log records in the queue of a given instance of an
-// SDK log processor.
-type SDKProcessorLogQueueSize struct {
-	metric.Int64ObservableUpDownCounter
-}
-
-var newSDKProcessorLogQueueSizeOpts = []metric.Int64ObservableUpDownCounterOption{
-	metric.WithDescription("The number of log records in the queue of a given instance of an SDK log processor."),
-	metric.WithUnit("{log_record}"),
-}
-
-// NewSDKProcessorLogQueueSize returns a new SDKProcessorLogQueueSize instrument.
-func NewSDKProcessorLogQueueSize(
-	m metric.Meter,
-	opt ...metric.Int64ObservableUpDownCounterOption,
-) (SDKProcessorLogQueueSize, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKProcessorLogQueueSize{noop.Int64ObservableUpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKProcessorLogQueueSizeOpts
-	} else {
-		opt = append(opt, newSDKProcessorLogQueueSizeOpts...)
-	}
-
-	i, err := m.Int64ObservableUpDownCounter(
-		"otel.sdk.processor.log.queue.size",
-		opt...,
-	)
-	if err != nil {
-		return SDKProcessorLogQueueSize{noop.Int64ObservableUpDownCounter{}}, err
-	}
-	return SDKProcessorLogQueueSize{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKProcessorLogQueueSize) Inst() metric.Int64ObservableUpDownCounter {
-	return m.Int64ObservableUpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKProcessorLogQueueSize) Name() string {
-	return "otel.sdk.processor.log.queue.size"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKProcessorLogQueueSize) Unit() string {
-	return "{log_record}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKProcessorLogQueueSize) Description() string {
-	return "The number of log records in the queue of a given instance of an SDK log processor."
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKProcessorLogQueueSize) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKProcessorLogQueueSize) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// SDKProcessorSpanProcessed is an instrument used to record metric values
-// conforming to the "otel.sdk.processor.span.processed" semantic conventions. It
-// represents the number of spans for which the processing has finished, either
-// successful or failed.
-type SDKProcessorSpanProcessed struct {
-	metric.Int64Counter
-}
-
-var newSDKProcessorSpanProcessedOpts = []metric.Int64CounterOption{
-	metric.WithDescription("The number of spans for which the processing has finished, either successful or failed."),
-	metric.WithUnit("{span}"),
-}
-
-// NewSDKProcessorSpanProcessed returns a new SDKProcessorSpanProcessed
-// instrument.
-func NewSDKProcessorSpanProcessed(
-	m metric.Meter,
-	opt ...metric.Int64CounterOption,
-) (SDKProcessorSpanProcessed, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKProcessorSpanProcessed{noop.Int64Counter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKProcessorSpanProcessedOpts
-	} else {
-		opt = append(opt, newSDKProcessorSpanProcessedOpts...)
-	}
-
-	i, err := m.Int64Counter(
-		"otel.sdk.processor.span.processed",
-		opt...,
-	)
-	if err != nil {
-		return SDKProcessorSpanProcessed{noop.Int64Counter{}}, err
-	}
-	return SDKProcessorSpanProcessed{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKProcessorSpanProcessed) Inst() metric.Int64Counter {
-	return m.Int64Counter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKProcessorSpanProcessed) Name() string {
-	return "otel.sdk.processor.span.processed"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKProcessorSpanProcessed) Unit() string {
-	return "{span}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKProcessorSpanProcessed) Description() string {
-	return "The number of spans for which the processing has finished, either successful or failed."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// For successful processing, `error.type` MUST NOT be set. For failed
-// processing, `error.type` MUST contain the failure cause.
-// For the SDK Simple and Batching Span Processor a span is considered to be
-// processed already when it has been submitted to the exporter, not when the
-// corresponding export call has finished.
-func (m SDKProcessorSpanProcessed) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// For successful processing, `error.type` MUST NOT be set. For failed
-// processing, `error.type` MUST contain the failure cause.
-// For the SDK Simple and Batching Span Processor a span is considered to be
-// processed already when it has been submitted to the exporter, not when the
-// corresponding export call has finished.
-func (m SDKProcessorSpanProcessed) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AttrErrorType returns an optional attribute for the "error.type" semantic
-// convention. It represents a low-cardinality description of the failure reason.
-// SDK Batching Span Processors MUST use `queue_full` for spans dropped due to a
-// full queue.
-func (SDKProcessorSpanProcessed) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
-	return attribute.String("error.type", string(val))
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKProcessorSpanProcessed) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKProcessorSpanProcessed) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// SDKProcessorSpanQueueCapacity is an instrument used to record metric values
-// conforming to the "otel.sdk.processor.span.queue.capacity" semantic
-// conventions. It represents the maximum number of spans the queue of a given
-// instance of an SDK span processor can hold.
-type SDKProcessorSpanQueueCapacity struct {
-	metric.Int64ObservableUpDownCounter
-}
-
-var newSDKProcessorSpanQueueCapacityOpts = []metric.Int64ObservableUpDownCounterOption{
-	metric.WithDescription("The maximum number of spans the queue of a given instance of an SDK span processor can hold."),
-	metric.WithUnit("{span}"),
-}
-
-// NewSDKProcessorSpanQueueCapacity returns a new SDKProcessorSpanQueueCapacity
-// instrument.
-func NewSDKProcessorSpanQueueCapacity(
-	m metric.Meter,
-	opt ...metric.Int64ObservableUpDownCounterOption,
-) (SDKProcessorSpanQueueCapacity, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKProcessorSpanQueueCapacity{noop.Int64ObservableUpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKProcessorSpanQueueCapacityOpts
-	} else {
-		opt = append(opt, newSDKProcessorSpanQueueCapacityOpts...)
-	}
-
-	i, err := m.Int64ObservableUpDownCounter(
-		"otel.sdk.processor.span.queue.capacity",
-		opt...,
-	)
-	if err != nil {
-		return SDKProcessorSpanQueueCapacity{noop.Int64ObservableUpDownCounter{}}, err
-	}
-	return SDKProcessorSpanQueueCapacity{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKProcessorSpanQueueCapacity) Inst() metric.Int64ObservableUpDownCounter {
-	return m.Int64ObservableUpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKProcessorSpanQueueCapacity) Name() string {
-	return "otel.sdk.processor.span.queue.capacity"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKProcessorSpanQueueCapacity) Unit() string {
-	return "{span}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKProcessorSpanQueueCapacity) Description() string {
-	return "The maximum number of spans the queue of a given instance of an SDK span processor can hold."
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKProcessorSpanQueueCapacity) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKProcessorSpanQueueCapacity) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// SDKProcessorSpanQueueSize is an instrument used to record metric values
-// conforming to the "otel.sdk.processor.span.queue.size" semantic conventions.
-// It represents the number of spans in the queue of a given instance of an SDK
-// span processor.
-type SDKProcessorSpanQueueSize struct {
-	metric.Int64ObservableUpDownCounter
-}
-
-var newSDKProcessorSpanQueueSizeOpts = []metric.Int64ObservableUpDownCounterOption{
-	metric.WithDescription("The number of spans in the queue of a given instance of an SDK span processor."),
-	metric.WithUnit("{span}"),
-}
-
-// NewSDKProcessorSpanQueueSize returns a new SDKProcessorSpanQueueSize
-// instrument.
-func NewSDKProcessorSpanQueueSize(
-	m metric.Meter,
-	opt ...metric.Int64ObservableUpDownCounterOption,
-) (SDKProcessorSpanQueueSize, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKProcessorSpanQueueSize{noop.Int64ObservableUpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKProcessorSpanQueueSizeOpts
-	} else {
-		opt = append(opt, newSDKProcessorSpanQueueSizeOpts...)
-	}
-
-	i, err := m.Int64ObservableUpDownCounter(
-		"otel.sdk.processor.span.queue.size",
-		opt...,
-	)
-	if err != nil {
-		return SDKProcessorSpanQueueSize{noop.Int64ObservableUpDownCounter{}}, err
-	}
-	return SDKProcessorSpanQueueSize{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKProcessorSpanQueueSize) Inst() metric.Int64ObservableUpDownCounter {
-	return m.Int64ObservableUpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKProcessorSpanQueueSize) Name() string {
-	return "otel.sdk.processor.span.queue.size"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKProcessorSpanQueueSize) Unit() string {
-	return "{span}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKProcessorSpanQueueSize) Description() string {
-	return "The number of spans in the queue of a given instance of an SDK span processor."
-}
-
-// AttrComponentName returns an optional attribute for the "otel.component.name"
-// semantic convention. It represents a name uniquely identifying the instance of
-// the OpenTelemetry component within its containing SDK instance.
-func (SDKProcessorSpanQueueSize) AttrComponentName(val string) attribute.KeyValue {
-	return attribute.String("otel.component.name", val)
-}
-
-// AttrComponentType returns an optional attribute for the "otel.component.type"
-// semantic convention. It represents a name identifying the type of the
-// OpenTelemetry component.
-func (SDKProcessorSpanQueueSize) AttrComponentType(val ComponentTypeAttr) attribute.KeyValue {
-	return attribute.String("otel.component.type", string(val))
-}
-
-// SDKSpanLive is an instrument used to record metric values conforming to the
-// "otel.sdk.span.live" semantic conventions. It represents the number of created
-// spans with `recording=true` for which the end operation has not been called
-// yet.
-type SDKSpanLive struct {
-	metric.Int64UpDownCounter
-}
-
-var newSDKSpanLiveOpts = []metric.Int64UpDownCounterOption{
-	metric.WithDescription("The number of created spans with `recording=true` for which the end operation has not been called yet."),
-	metric.WithUnit("{span}"),
-}
-
-// NewSDKSpanLive returns a new SDKSpanLive instrument.
-func NewSDKSpanLive(
-	m metric.Meter,
-	opt ...metric.Int64UpDownCounterOption,
-) (SDKSpanLive, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKSpanLive{noop.Int64UpDownCounter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKSpanLiveOpts
-	} else {
-		opt = append(opt, newSDKSpanLiveOpts...)
-	}
-
-	i, err := m.Int64UpDownCounter(
-		"otel.sdk.span.live",
-		opt...,
-	)
-	if err != nil {
-		return SDKSpanLive{noop.Int64UpDownCounter{}}, err
-	}
-	return SDKSpanLive{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKSpanLive) Inst() metric.Int64UpDownCounter {
-	return m.Int64UpDownCounter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKSpanLive) Name() string {
-	return "otel.sdk.span.live"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKSpanLive) Unit() string {
-	return "{span}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKSpanLive) Description() string {
-	return "The number of created spans with `recording=true` for which the end operation has not been called yet."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-func (m SDKSpanLive) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-func (m SDKSpanLive) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64UpDownCounter.Add(ctx, incr, *o...)
-}
-
-// AttrSpanSamplingResult returns an optional attribute for the
-// "otel.span.sampling_result" semantic convention. It represents the result
-// value of the sampler for this span.
-func (SDKSpanLive) AttrSpanSamplingResult(val SpanSamplingResultAttr) attribute.KeyValue {
-	return attribute.String("otel.span.sampling_result", string(val))
-}
-
-// SDKSpanStarted is an instrument used to record metric values conforming to the
-// "otel.sdk.span.started" semantic conventions. It represents the number of
-// created spans.
-type SDKSpanStarted struct {
-	metric.Int64Counter
-}
-
-var newSDKSpanStartedOpts = []metric.Int64CounterOption{
-	metric.WithDescription("The number of created spans."),
-	metric.WithUnit("{span}"),
-}
-
-// NewSDKSpanStarted returns a new SDKSpanStarted instrument.
-func NewSDKSpanStarted(
-	m metric.Meter,
-	opt ...metric.Int64CounterOption,
-) (SDKSpanStarted, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return SDKSpanStarted{noop.Int64Counter{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newSDKSpanStartedOpts
-	} else {
-		opt = append(opt, newSDKSpanStartedOpts...)
-	}
-
-	i, err := m.Int64Counter(
-		"otel.sdk.span.started",
-		opt...,
-	)
-	if err != nil {
-		return SDKSpanStarted{noop.Int64Counter{}}, err
-	}
-	return SDKSpanStarted{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m SDKSpanStarted) Inst() metric.Int64Counter {
-	return m.Int64Counter
-}
-
-// Name returns the semantic convention name of the instrument.
-func (SDKSpanStarted) Name() string {
-	return "otel.sdk.span.started"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (SDKSpanStarted) Unit() string {
-	return "{span}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (SDKSpanStarted) Description() string {
-	return "The number of created spans."
-}
-
-// Add adds incr to the existing count for attrs.
-//
-// All additional attrs passed are included in the recorded value.
-//
-// Implementations MUST record this metric for all spans, even for non-recording
-// ones.
-func (m SDKSpanStarted) Add(
-	ctx context.Context,
-	incr int64,
-	attrs ...attribute.KeyValue,
-) {
-	if len(attrs) == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(
-		*o,
-		metric.WithAttributes(
-			attrs...,
-		),
-	)
-
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AddSet adds incr to the existing count for set.
-//
-// Implementations MUST record this metric for all spans, even for non-recording
-// ones.
-func (m SDKSpanStarted) AddSet(ctx context.Context, incr int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Counter.Add(ctx, incr)
-		return
-	}
-
-	o := addOptPool.Get().(*[]metric.AddOption)
-	defer func() {
-		*o = (*o)[:0]
-		addOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Counter.Add(ctx, incr, *o...)
-}
-
-// AttrSpanParentOrigin returns an optional attribute for the
-// "otel.span.parent.origin" semantic convention. It represents the determines
-// whether the span has a parent span, and if so, [whether it is a remote parent]
-// .
-//
-// [whether it is a remote parent]: https://opentelemetry.io/docs/specs/otel/trace/api/#isremote
-func (SDKSpanStarted) AttrSpanParentOrigin(val SpanParentOriginAttr) attribute.KeyValue {
-	return attribute.String("otel.span.parent.origin", string(val))
-}
-
-// AttrSpanSamplingResult returns an optional attribute for the
-// "otel.span.sampling_result" semantic convention. It represents the result
-// value of the sampler for this span.
-func (SDKSpanStarted) AttrSpanSamplingResult(val SpanSamplingResultAttr) attribute.KeyValue {
-	return attribute.String("otel.span.sampling_result", string(val))
-}
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/rpcconv/metric.go b/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/rpcconv/metric.go
deleted file mode 100644
index 089b0c457fca8..0000000000000
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/rpcconv/metric.go
+++ /dev/null
@@ -1,1010 +0,0 @@
-// Code generated from semantic convention specification. DO NOT EDIT.
-
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-// Package rpcconv provides types and functionality for OpenTelemetry semantic
-// conventions in the "rpc" namespace.
-package rpcconv
-
-import (
-	"context"
-	"sync"
-
-	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
-	"go.opentelemetry.io/otel/metric/noop"
-)
-
-var (
-	addOptPool = &sync.Pool{New: func() any { return &[]metric.AddOption{} }}
-	recOptPool = &sync.Pool{New: func() any { return &[]metric.RecordOption{} }}
-)
-
-// ClientDuration is an instrument used to record metric values conforming to the
-// "rpc.client.duration" semantic conventions. It represents the measures the
-// duration of outbound RPC.
-type ClientDuration struct {
-	metric.Float64Histogram
-}
-
-var newClientDurationOpts = []metric.Float64HistogramOption{
-	metric.WithDescription("Measures the duration of outbound RPC."),
-	metric.WithUnit("ms"),
-}
-
-// NewClientDuration returns a new ClientDuration instrument.
-func NewClientDuration(
-	m metric.Meter,
-	opt ...metric.Float64HistogramOption,
-) (ClientDuration, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ClientDuration{noop.Float64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newClientDurationOpts
-	} else {
-		opt = append(opt, newClientDurationOpts...)
-	}
-
-	i, err := m.Float64Histogram(
-		"rpc.client.duration",
-		opt...,
-	)
-	if err != nil {
-		return ClientDuration{noop.Float64Histogram{}}, err
-	}
-	return ClientDuration{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ClientDuration) Inst() metric.Float64Histogram {
-	return m.Float64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ClientDuration) Name() string {
-	return "rpc.client.duration"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ClientDuration) Unit() string {
-	return "ms"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ClientDuration) Description() string {
-	return "Measures the duration of outbound RPC."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// While streaming RPCs may record this metric as start-of-batch
-// to end-of-batch, it's hard to interpret in practice.
-//
-// **Streaming**: N/A.
-func (m ClientDuration) Record(ctx context.Context, val float64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// While streaming RPCs may record this metric as start-of-batch
-// to end-of-batch, it's hard to interpret in practice.
-//
-// **Streaming**: N/A.
-func (m ClientDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// ClientRequestSize is an instrument used to record metric values conforming to
-// the "rpc.client.request.size" semantic conventions. It represents the measures
-// the size of RPC request messages (uncompressed).
-type ClientRequestSize struct {
-	metric.Int64Histogram
-}
-
-var newClientRequestSizeOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the size of RPC request messages (uncompressed)."),
-	metric.WithUnit("By"),
-}
-
-// NewClientRequestSize returns a new ClientRequestSize instrument.
-func NewClientRequestSize(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ClientRequestSize, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ClientRequestSize{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newClientRequestSizeOpts
-	} else {
-		opt = append(opt, newClientRequestSizeOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.client.request.size",
-		opt...,
-	)
-	if err != nil {
-		return ClientRequestSize{noop.Int64Histogram{}}, err
-	}
-	return ClientRequestSize{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ClientRequestSize) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ClientRequestSize) Name() string {
-	return "rpc.client.request.size"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ClientRequestSize) Unit() string {
-	return "By"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ClientRequestSize) Description() string {
-	return "Measures the size of RPC request messages (uncompressed)."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// **Streaming**: Recorded per message in a streaming batch
-func (m ClientRequestSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// **Streaming**: Recorded per message in a streaming batch
-func (m ClientRequestSize) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// ClientRequestsPerRPC is an instrument used to record metric values conforming
-// to the "rpc.client.requests_per_rpc" semantic conventions. It represents the
-// measures the number of messages received per RPC.
-type ClientRequestsPerRPC struct {
-	metric.Int64Histogram
-}
-
-var newClientRequestsPerRPCOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the number of messages received per RPC."),
-	metric.WithUnit("{count}"),
-}
-
-// NewClientRequestsPerRPC returns a new ClientRequestsPerRPC instrument.
-func NewClientRequestsPerRPC(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ClientRequestsPerRPC, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ClientRequestsPerRPC{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newClientRequestsPerRPCOpts
-	} else {
-		opt = append(opt, newClientRequestsPerRPCOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.client.requests_per_rpc",
-		opt...,
-	)
-	if err != nil {
-		return ClientRequestsPerRPC{noop.Int64Histogram{}}, err
-	}
-	return ClientRequestsPerRPC{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ClientRequestsPerRPC) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ClientRequestsPerRPC) Name() string {
-	return "rpc.client.requests_per_rpc"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ClientRequestsPerRPC) Unit() string {
-	return "{count}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ClientRequestsPerRPC) Description() string {
-	return "Measures the number of messages received per RPC."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming**: This metric is required for server and client streaming RPCs
-func (m ClientRequestsPerRPC) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming**: This metric is required for server and client streaming RPCs
-func (m ClientRequestsPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// ClientResponseSize is an instrument used to record metric values conforming to
-// the "rpc.client.response.size" semantic conventions. It represents the
-// measures the size of RPC response messages (uncompressed).
-type ClientResponseSize struct {
-	metric.Int64Histogram
-}
-
-var newClientResponseSizeOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the size of RPC response messages (uncompressed)."),
-	metric.WithUnit("By"),
-}
-
-// NewClientResponseSize returns a new ClientResponseSize instrument.
-func NewClientResponseSize(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ClientResponseSize, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ClientResponseSize{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newClientResponseSizeOpts
-	} else {
-		opt = append(opt, newClientResponseSizeOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.client.response.size",
-		opt...,
-	)
-	if err != nil {
-		return ClientResponseSize{noop.Int64Histogram{}}, err
-	}
-	return ClientResponseSize{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ClientResponseSize) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ClientResponseSize) Name() string {
-	return "rpc.client.response.size"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ClientResponseSize) Unit() string {
-	return "By"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ClientResponseSize) Description() string {
-	return "Measures the size of RPC response messages (uncompressed)."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// **Streaming**: Recorded per response in a streaming batch
-func (m ClientResponseSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// **Streaming**: Recorded per response in a streaming batch
-func (m ClientResponseSize) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// ClientResponsesPerRPC is an instrument used to record metric values conforming
-// to the "rpc.client.responses_per_rpc" semantic conventions. It represents the
-// measures the number of messages sent per RPC.
-type ClientResponsesPerRPC struct {
-	metric.Int64Histogram
-}
-
-var newClientResponsesPerRPCOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the number of messages sent per RPC."),
-	metric.WithUnit("{count}"),
-}
-
-// NewClientResponsesPerRPC returns a new ClientResponsesPerRPC instrument.
-func NewClientResponsesPerRPC(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ClientResponsesPerRPC, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ClientResponsesPerRPC{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newClientResponsesPerRPCOpts
-	} else {
-		opt = append(opt, newClientResponsesPerRPCOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.client.responses_per_rpc",
-		opt...,
-	)
-	if err != nil {
-		return ClientResponsesPerRPC{noop.Int64Histogram{}}, err
-	}
-	return ClientResponsesPerRPC{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ClientResponsesPerRPC) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ClientResponsesPerRPC) Name() string {
-	return "rpc.client.responses_per_rpc"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ClientResponsesPerRPC) Unit() string {
-	return "{count}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ClientResponsesPerRPC) Description() string {
-	return "Measures the number of messages sent per RPC."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming**: This metric is required for server and client streaming RPCs
-func (m ClientResponsesPerRPC) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming**: This metric is required for server and client streaming RPCs
-func (m ClientResponsesPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// ServerDuration is an instrument used to record metric values conforming to the
-// "rpc.server.duration" semantic conventions. It represents the measures the
-// duration of inbound RPC.
-type ServerDuration struct {
-	metric.Float64Histogram
-}
-
-var newServerDurationOpts = []metric.Float64HistogramOption{
-	metric.WithDescription("Measures the duration of inbound RPC."),
-	metric.WithUnit("ms"),
-}
-
-// NewServerDuration returns a new ServerDuration instrument.
-func NewServerDuration(
-	m metric.Meter,
-	opt ...metric.Float64HistogramOption,
-) (ServerDuration, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ServerDuration{noop.Float64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newServerDurationOpts
-	} else {
-		opt = append(opt, newServerDurationOpts...)
-	}
-
-	i, err := m.Float64Histogram(
-		"rpc.server.duration",
-		opt...,
-	)
-	if err != nil {
-		return ServerDuration{noop.Float64Histogram{}}, err
-	}
-	return ServerDuration{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ServerDuration) Inst() metric.Float64Histogram {
-	return m.Float64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ServerDuration) Name() string {
-	return "rpc.server.duration"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ServerDuration) Unit() string {
-	return "ms"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ServerDuration) Description() string {
-	return "Measures the duration of inbound RPC."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// While streaming RPCs may record this metric as start-of-batch
-// to end-of-batch, it's hard to interpret in practice.
-//
-// **Streaming**: N/A.
-func (m ServerDuration) Record(ctx context.Context, val float64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// While streaming RPCs may record this metric as start-of-batch
-// to end-of-batch, it's hard to interpret in practice.
-//
-// **Streaming**: N/A.
-func (m ServerDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Float64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Float64Histogram.Record(ctx, val, *o...)
-}
-
-// ServerRequestSize is an instrument used to record metric values conforming to
-// the "rpc.server.request.size" semantic conventions. It represents the measures
-// the size of RPC request messages (uncompressed).
-type ServerRequestSize struct {
-	metric.Int64Histogram
-}
-
-var newServerRequestSizeOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the size of RPC request messages (uncompressed)."),
-	metric.WithUnit("By"),
-}
-
-// NewServerRequestSize returns a new ServerRequestSize instrument.
-func NewServerRequestSize(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ServerRequestSize, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ServerRequestSize{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newServerRequestSizeOpts
-	} else {
-		opt = append(opt, newServerRequestSizeOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.server.request.size",
-		opt...,
-	)
-	if err != nil {
-		return ServerRequestSize{noop.Int64Histogram{}}, err
-	}
-	return ServerRequestSize{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ServerRequestSize) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ServerRequestSize) Name() string {
-	return "rpc.server.request.size"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ServerRequestSize) Unit() string {
-	return "By"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ServerRequestSize) Description() string {
-	return "Measures the size of RPC request messages (uncompressed)."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// **Streaming**: Recorded per message in a streaming batch
-func (m ServerRequestSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// **Streaming**: Recorded per message in a streaming batch
-func (m ServerRequestSize) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// ServerRequestsPerRPC is an instrument used to record metric values conforming
-// to the "rpc.server.requests_per_rpc" semantic conventions. It represents the
-// measures the number of messages received per RPC.
-type ServerRequestsPerRPC struct {
-	metric.Int64Histogram
-}
-
-var newServerRequestsPerRPCOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the number of messages received per RPC."),
-	metric.WithUnit("{count}"),
-}
-
-// NewServerRequestsPerRPC returns a new ServerRequestsPerRPC instrument.
-func NewServerRequestsPerRPC(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ServerRequestsPerRPC, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ServerRequestsPerRPC{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newServerRequestsPerRPCOpts
-	} else {
-		opt = append(opt, newServerRequestsPerRPCOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.server.requests_per_rpc",
-		opt...,
-	)
-	if err != nil {
-		return ServerRequestsPerRPC{noop.Int64Histogram{}}, err
-	}
-	return ServerRequestsPerRPC{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ServerRequestsPerRPC) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ServerRequestsPerRPC) Name() string {
-	return "rpc.server.requests_per_rpc"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ServerRequestsPerRPC) Unit() string {
-	return "{count}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ServerRequestsPerRPC) Description() string {
-	return "Measures the number of messages received per RPC."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming** : This metric is required for server and client streaming RPCs
-func (m ServerRequestsPerRPC) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming** : This metric is required for server and client streaming RPCs
-func (m ServerRequestsPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// ServerResponseSize is an instrument used to record metric values conforming to
-// the "rpc.server.response.size" semantic conventions. It represents the
-// measures the size of RPC response messages (uncompressed).
-type ServerResponseSize struct {
-	metric.Int64Histogram
-}
-
-var newServerResponseSizeOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the size of RPC response messages (uncompressed)."),
-	metric.WithUnit("By"),
-}
-
-// NewServerResponseSize returns a new ServerResponseSize instrument.
-func NewServerResponseSize(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ServerResponseSize, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ServerResponseSize{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newServerResponseSizeOpts
-	} else {
-		opt = append(opt, newServerResponseSizeOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.server.response.size",
-		opt...,
-	)
-	if err != nil {
-		return ServerResponseSize{noop.Int64Histogram{}}, err
-	}
-	return ServerResponseSize{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ServerResponseSize) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ServerResponseSize) Name() string {
-	return "rpc.server.response.size"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ServerResponseSize) Unit() string {
-	return "By"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ServerResponseSize) Description() string {
-	return "Measures the size of RPC response messages (uncompressed)."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// **Streaming**: Recorded per response in a streaming batch
-func (m ServerResponseSize) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// **Streaming**: Recorded per response in a streaming batch
-func (m ServerResponseSize) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// ServerResponsesPerRPC is an instrument used to record metric values conforming
-// to the "rpc.server.responses_per_rpc" semantic conventions. It represents the
-// measures the number of messages sent per RPC.
-type ServerResponsesPerRPC struct {
-	metric.Int64Histogram
-}
-
-var newServerResponsesPerRPCOpts = []metric.Int64HistogramOption{
-	metric.WithDescription("Measures the number of messages sent per RPC."),
-	metric.WithUnit("{count}"),
-}
-
-// NewServerResponsesPerRPC returns a new ServerResponsesPerRPC instrument.
-func NewServerResponsesPerRPC(
-	m metric.Meter,
-	opt ...metric.Int64HistogramOption,
-) (ServerResponsesPerRPC, error) {
-	// Check if the meter is nil.
-	if m == nil {
-		return ServerResponsesPerRPC{noop.Int64Histogram{}}, nil
-	}
-
-	if len(opt) == 0 {
-		opt = newServerResponsesPerRPCOpts
-	} else {
-		opt = append(opt, newServerResponsesPerRPCOpts...)
-	}
-
-	i, err := m.Int64Histogram(
-		"rpc.server.responses_per_rpc",
-		opt...,
-	)
-	if err != nil {
-		return ServerResponsesPerRPC{noop.Int64Histogram{}}, err
-	}
-	return ServerResponsesPerRPC{i}, nil
-}
-
-// Inst returns the underlying metric instrument.
-func (m ServerResponsesPerRPC) Inst() metric.Int64Histogram {
-	return m.Int64Histogram
-}
-
-// Name returns the semantic convention name of the instrument.
-func (ServerResponsesPerRPC) Name() string {
-	return "rpc.server.responses_per_rpc"
-}
-
-// Unit returns the semantic convention unit of the instrument
-func (ServerResponsesPerRPC) Unit() string {
-	return "{count}"
-}
-
-// Description returns the semantic convention description of the instrument
-func (ServerResponsesPerRPC) Description() string {
-	return "Measures the number of messages sent per RPC."
-}
-
-// Record records val to the current distribution for attrs.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming**: This metric is required for server and client streaming RPCs
-func (m ServerResponsesPerRPC) Record(ctx context.Context, val int64, attrs ...attribute.KeyValue) {
-	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributes(attrs...))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
-
-// RecordSet records val to the current distribution for set.
-//
-// Should be 1 for all non-streaming RPCs.
-//
-// **Streaming**: This metric is required for server and client streaming RPCs
-func (m ServerResponsesPerRPC) RecordSet(ctx context.Context, val int64, set attribute.Set) {
-	if set.Len() == 0 {
-		m.Int64Histogram.Record(ctx, val)
-		return
-	}
-
-	o := recOptPool.Get().(*[]metric.RecordOption)
-	defer func() {
-		*o = (*o)[:0]
-		recOptPool.Put(o)
-	}()
-
-	*o = append(*o, metric.WithAttributeSet(set))
-	m.Int64Histogram.Record(ctx, val, *o...)
-}
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/httpconv/metric.go b/vendor/go.opentelemetry.io/otel/semconv/v1.40.0/httpconv/metric.go
similarity index 94%
rename from vendor/go.opentelemetry.io/otel/semconv/v1.37.0/httpconv/metric.go
rename to vendor/go.opentelemetry.io/otel/semconv/v1.40.0/httpconv/metric.go
index a0ddf652d3436..7264925ba9a57 100644
--- a/vendor/go.opentelemetry.io/otel/semconv/v1.37.0/httpconv/metric.go
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.40.0/httpconv/metric.go
@@ -67,6 +67,8 @@ var (
 	RequestMethodPut RequestMethodAttr = "PUT"
 	// RequestMethodTrace is the TRACE method.
 	RequestMethodTrace RequestMethodAttr = "TRACE"
+	// RequestMethodQuery is the QUERY method.
+	RequestMethodQuery RequestMethodAttr = "QUERY"
 	// RequestMethodOther is the any HTTP method that the instrumentation has no
 	// prior knowledge of.
 	RequestMethodOther RequestMethodAttr = "_OTHER"
@@ -158,7 +160,10 @@ func (m ClientActiveRequests) Add(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
+		m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes(
+			attribute.String("server.address", serverAddress),
+			attribute.Int("server.port", serverPort),
+		))
 		return
 	}
 
@@ -172,7 +177,7 @@ func (m ClientActiveRequests) Add(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("server.address", serverAddress),
 				attribute.Int("server.port", serverPort),
 			)...,
@@ -298,7 +303,10 @@ func (m ClientConnectionDuration) Record(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Float64Histogram.Record(ctx, val)
+		m.Float64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("server.address", serverAddress),
+			attribute.Int("server.port", serverPort),
+		))
 		return
 	}
 
@@ -312,7 +320,7 @@ func (m ClientConnectionDuration) Record(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("server.address", serverAddress),
 				attribute.Int("server.port", serverPort),
 			)...,
@@ -441,7 +449,11 @@ func (m ClientOpenConnections) Add(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
+		m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes(
+			attribute.String("http.connection.state", string(connectionState)),
+			attribute.String("server.address", serverAddress),
+			attribute.Int("server.port", serverPort),
+		))
 		return
 	}
 
@@ -455,7 +467,7 @@ func (m ClientOpenConnections) Add(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.connection.state", string(connectionState)),
 				attribute.String("server.address", serverAddress),
 				attribute.Int("server.port", serverPort),
@@ -590,7 +602,11 @@ func (m ClientRequestBodySize) Record(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
+		m.Int64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("http.request.method", string(requestMethod)),
+			attribute.String("server.address", serverAddress),
+			attribute.Int("server.port", serverPort),
+		))
 		return
 	}
 
@@ -604,7 +620,7 @@ func (m ClientRequestBodySize) Record(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.request.method", string(requestMethod)),
 				attribute.String("server.address", serverAddress),
 				attribute.Int("server.port", serverPort),
@@ -766,7 +782,11 @@ func (m ClientRequestDuration) Record(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Float64Histogram.Record(ctx, val)
+		m.Float64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("http.request.method", string(requestMethod)),
+			attribute.String("server.address", serverAddress),
+			attribute.Int("server.port", serverPort),
+		))
 		return
 	}
 
@@ -780,7 +800,7 @@ func (m ClientRequestDuration) Record(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.request.method", string(requestMethod)),
 				attribute.String("server.address", serverAddress),
 				attribute.Int("server.port", serverPort),
@@ -942,7 +962,11 @@ func (m ClientResponseBodySize) Record(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
+		m.Int64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("http.request.method", string(requestMethod)),
+			attribute.String("server.address", serverAddress),
+			attribute.Int("server.port", serverPort),
+		))
 		return
 	}
 
@@ -956,7 +980,7 @@ func (m ClientResponseBodySize) Record(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.request.method", string(requestMethod)),
 				attribute.String("server.address", serverAddress),
 				attribute.Int("server.port", serverPort),
@@ -1116,7 +1140,10 @@ func (m ServerActiveRequests) Add(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Int64UpDownCounter.Add(ctx, incr)
+		m.Int64UpDownCounter.Add(ctx, incr, metric.WithAttributes(
+			attribute.String("http.request.method", string(requestMethod)),
+			attribute.String("url.scheme", urlScheme),
+		))
 		return
 	}
 
@@ -1130,7 +1157,7 @@ func (m ServerActiveRequests) Add(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.request.method", string(requestMethod)),
 				attribute.String("url.scheme", urlScheme),
 			)...,
@@ -1253,7 +1280,10 @@ func (m ServerRequestBodySize) Record(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
+		m.Int64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("http.request.method", string(requestMethod)),
+			attribute.String("url.scheme", urlScheme),
+		))
 		return
 	}
 
@@ -1267,7 +1297,7 @@ func (m ServerRequestBodySize) Record(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.request.method", string(requestMethod)),
 				attribute.String("url.scheme", urlScheme),
 			)...,
@@ -1318,8 +1348,9 @@ func (ServerRequestBodySize) AttrResponseStatusCode(val int) attribute.KeyValue
 }
 
 // AttrRoute returns an optional attribute for the "http.route" semantic
-// convention. It represents the matched route, that is, the path template in the
-// format used by the respective server framework.
+// convention. It represents the matched route template for the request. This
+// MUST be low-cardinality and include all static path segments, with dynamic
+// path segments represented with placeholders.
 func (ServerRequestBodySize) AttrRoute(val string) attribute.KeyValue {
 	return attribute.String("http.route", val)
 }
@@ -1436,7 +1467,10 @@ func (m ServerRequestDuration) Record(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Float64Histogram.Record(ctx, val)
+		m.Float64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("http.request.method", string(requestMethod)),
+			attribute.String("url.scheme", urlScheme),
+		))
 		return
 	}
 
@@ -1450,7 +1484,7 @@ func (m ServerRequestDuration) Record(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.request.method", string(requestMethod)),
 				attribute.String("url.scheme", urlScheme),
 			)...,
@@ -1494,8 +1528,9 @@ func (ServerRequestDuration) AttrResponseStatusCode(val int) attribute.KeyValue
 }
 
 // AttrRoute returns an optional attribute for the "http.route" semantic
-// convention. It represents the matched route, that is, the path template in the
-// format used by the respective server framework.
+// convention. It represents the matched route template for the request. This
+// MUST be low-cardinality and include all static path segments, with dynamic
+// path segments represented with placeholders.
 func (ServerRequestDuration) AttrRoute(val string) attribute.KeyValue {
 	return attribute.String("http.route", val)
 }
@@ -1619,7 +1654,10 @@ func (m ServerResponseBodySize) Record(
 	attrs ...attribute.KeyValue,
 ) {
 	if len(attrs) == 0 {
-		m.Int64Histogram.Record(ctx, val)
+		m.Int64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("http.request.method", string(requestMethod)),
+			attribute.String("url.scheme", urlScheme),
+		))
 		return
 	}
 
@@ -1633,7 +1671,7 @@ func (m ServerResponseBodySize) Record(
 		*o,
 		metric.WithAttributes(
 			append(
-				attrs,
+				attrs[:len(attrs):len(attrs)],
 				attribute.String("http.request.method", string(requestMethod)),
 				attribute.String("url.scheme", urlScheme),
 			)...,
@@ -1684,8 +1722,9 @@ func (ServerResponseBodySize) AttrResponseStatusCode(val int) attribute.KeyValue
 }
 
 // AttrRoute returns an optional attribute for the "http.route" semantic
-// convention. It represents the matched route, that is, the path template in the
-// format used by the respective server framework.
+// convention. It represents the matched route template for the request. This
+// MUST be low-cardinality and include all static path segments, with dynamic
+// path segments represented with placeholders.
 func (ServerResponseBodySize) AttrRoute(val string) attribute.KeyValue {
 	return attribute.String("http.route", val)
 }
diff --git a/vendor/go.opentelemetry.io/otel/semconv/v1.40.0/rpcconv/metric.go b/vendor/go.opentelemetry.io/otel/semconv/v1.40.0/rpcconv/metric.go
new file mode 100644
index 0000000000000..2086ffce5dcc3
--- /dev/null
+++ b/vendor/go.opentelemetry.io/otel/semconv/v1.40.0/rpcconv/metric.go
@@ -0,0 +1,360 @@
+// Code generated from semantic convention specification. DO NOT EDIT.
+
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Package rpcconv provides types and functionality for OpenTelemetry semantic
+// conventions in the "rpc" namespace.
+package rpcconv
+
+import (
+	"context"
+	"sync"
+
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/metric"
+	"go.opentelemetry.io/otel/metric/noop"
+)
+
+var (
+	addOptPool = &sync.Pool{New: func() any { return &[]metric.AddOption{} }}
+	recOptPool = &sync.Pool{New: func() any { return &[]metric.RecordOption{} }}
+)
+
+// ErrorTypeAttr is an attribute conforming to the error.type semantic
+// conventions. It represents the describes a class of error the operation ended
+// with.
+type ErrorTypeAttr string
+
+var (
+	// ErrorTypeOther is a fallback error value to be used when the instrumentation
+	// doesn't define a custom value.
+	ErrorTypeOther ErrorTypeAttr = "_OTHER"
+)
+
+// SystemNameAttr is an attribute conforming to the rpc.system.name semantic
+// conventions. It represents the Remote Procedure Call (RPC) system.
+type SystemNameAttr string
+
+var (
+	// SystemNameGRPC is the [gRPC].
+	//
+	// [gRPC]: https://grpc.io/
+	SystemNameGRPC SystemNameAttr = "grpc"
+	// SystemNameDubbo is the [Apache Dubbo].
+	//
+	// [Apache Dubbo]: https://dubbo.apache.org/
+	SystemNameDubbo SystemNameAttr = "dubbo"
+	// SystemNameConnectrpc is the [Connect RPC].
+	//
+	// [Connect RPC]: https://connectrpc.com/
+	SystemNameConnectrpc SystemNameAttr = "connectrpc"
+	// SystemNameJSONRPC is the [JSON-RPC].
+	//
+	// [JSON-RPC]: https://www.jsonrpc.org/
+	SystemNameJSONRPC SystemNameAttr = "jsonrpc"
+)
+
+// ClientCallDuration is an instrument used to record metric values conforming to
+// the "rpc.client.call.duration" semantic conventions. It represents the
+// measures the duration of an outgoing Remote Procedure Call (RPC).
+type ClientCallDuration struct {
+	metric.Float64Histogram
+}
+
+var newClientCallDurationOpts = []metric.Float64HistogramOption{
+	metric.WithDescription("Measures the duration of an outgoing Remote Procedure Call (RPC)."),
+	metric.WithUnit("s"),
+}
+
+// NewClientCallDuration returns a new ClientCallDuration instrument.
+func NewClientCallDuration(
+	m metric.Meter,
+	opt ...metric.Float64HistogramOption,
+) (ClientCallDuration, error) {
+	// Check if the meter is nil.
+	if m == nil {
+		return ClientCallDuration{noop.Float64Histogram{}}, nil
+	}
+
+	if len(opt) == 0 {
+		opt = newClientCallDurationOpts
+	} else {
+		opt = append(opt, newClientCallDurationOpts...)
+	}
+
+	i, err := m.Float64Histogram(
+		"rpc.client.call.duration",
+		opt...,
+	)
+	if err != nil {
+		return ClientCallDuration{noop.Float64Histogram{}}, err
+	}
+	return ClientCallDuration{i}, nil
+}
+
+// Inst returns the underlying metric instrument.
+func (m ClientCallDuration) Inst() metric.Float64Histogram {
+	return m.Float64Histogram
+}
+
+// Name returns the semantic convention name of the instrument.
+func (ClientCallDuration) Name() string {
+	return "rpc.client.call.duration"
+}
+
+// Unit returns the semantic convention unit of the instrument
+func (ClientCallDuration) Unit() string {
+	return "s"
+}
+
+// Description returns the semantic convention description of the instrument
+func (ClientCallDuration) Description() string {
+	return "Measures the duration of an outgoing Remote Procedure Call (RPC)."
+}
+
+// Record records val to the current distribution for attrs.
+//
+// The systemName is the the Remote Procedure Call (RPC) system.
+//
+// All additional attrs passed are included in the recorded value.
+//
+// When this metric is reported alongside an RPC client span, the metric value
+// SHOULD be the same as the RPC client span duration.
+func (m ClientCallDuration) Record(
+	ctx context.Context,
+	val float64,
+	systemName SystemNameAttr,
+	attrs ...attribute.KeyValue,
+) {
+	if len(attrs) == 0 {
+		m.Float64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("rpc.system.name", string(systemName)),
+		))
+		return
+	}
+
+	o := recOptPool.Get().(*[]metric.RecordOption)
+	defer func() {
+		*o = (*o)[:0]
+		recOptPool.Put(o)
+	}()
+
+	*o = append(
+		*o,
+		metric.WithAttributes(
+			append(
+				attrs[:len(attrs):len(attrs)],
+				attribute.String("rpc.system.name", string(systemName)),
+			)...,
+		),
+	)
+
+	m.Float64Histogram.Record(ctx, val, *o...)
+}
+
+// RecordSet records val to the current distribution for set.
+//
+// When this metric is reported alongside an RPC client span, the metric value
+// SHOULD be the same as the RPC client span duration.
+func (m ClientCallDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) {
+	if set.Len() == 0 {
+		m.Float64Histogram.Record(ctx, val)
+		return
+	}
+
+	o := recOptPool.Get().(*[]metric.RecordOption)
+	defer func() {
+		*o = (*o)[:0]
+		recOptPool.Put(o)
+	}()
+
+	*o = append(*o, metric.WithAttributeSet(set))
+	m.Float64Histogram.Record(ctx, val, *o...)
+}
+
+// AttrErrorType returns an optional attribute for the "error.type" semantic
+// convention. It represents the describes a class of error the operation ended
+// with.
+func (ClientCallDuration) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
+	return attribute.String("error.type", string(val))
+}
+
+// AttrMethod returns an optional attribute for the "rpc.method" semantic
+// convention. It represents the fully-qualified logical name of the method from
+// the RPC interface perspective.
+func (ClientCallDuration) AttrMethod(val string) attribute.KeyValue {
+	return attribute.String("rpc.method", val)
+}
+
+// AttrResponseStatusCode returns an optional attribute for the
+// "rpc.response.status_code" semantic convention. It represents the status code
+// of the RPC returned by the RPC server or generated by the client.
+func (ClientCallDuration) AttrResponseStatusCode(val string) attribute.KeyValue {
+	return attribute.String("rpc.response.status_code", val)
+}
+
+// AttrServerAddress returns an optional attribute for the "server.address"
+// semantic convention. It represents a string identifying a group of RPC server
+// instances request is sent to.
+func (ClientCallDuration) AttrServerAddress(val string) attribute.KeyValue {
+	return attribute.String("server.address", val)
+}
+
+// AttrServerPort returns an optional attribute for the "server.port" semantic
+// convention. It represents the server port number.
+func (ClientCallDuration) AttrServerPort(val int) attribute.KeyValue {
+	return attribute.Int("server.port", val)
+}
+
+// ServerCallDuration is an instrument used to record metric values conforming to
+// the "rpc.server.call.duration" semantic conventions. It represents the
+// measures the duration of an incoming Remote Procedure Call (RPC).
+type ServerCallDuration struct {
+	metric.Float64Histogram
+}
+
+var newServerCallDurationOpts = []metric.Float64HistogramOption{
+	metric.WithDescription("Measures the duration of an incoming Remote Procedure Call (RPC)."),
+	metric.WithUnit("s"),
+}
+
+// NewServerCallDuration returns a new ServerCallDuration instrument.
+func NewServerCallDuration(
+	m metric.Meter,
+	opt ...metric.Float64HistogramOption,
+) (ServerCallDuration, error) {
+	// Check if the meter is nil.
+	if m == nil {
+		return ServerCallDuration{noop.Float64Histogram{}}, nil
+	}
+
+	if len(opt) == 0 {
+		opt = newServerCallDurationOpts
+	} else {
+		opt = append(opt, newServerCallDurationOpts...)
+	}
+
+	i, err := m.Float64Histogram(
+		"rpc.server.call.duration",
+		opt...,
+	)
+	if err != nil {
+		return ServerCallDuration{noop.Float64Histogram{}}, err
+	}
+	return ServerCallDuration{i}, nil
+}
+
+// Inst returns the underlying metric instrument.
+func (m ServerCallDuration) Inst() metric.Float64Histogram {
+	return m.Float64Histogram
+}
+
+// Name returns the semantic convention name of the instrument.
+func (ServerCallDuration) Name() string {
+	return "rpc.server.call.duration"
+}
+
+// Unit returns the semantic convention unit of the instrument
+func (ServerCallDuration) Unit() string {
+	return "s"
+}
+
+// Description returns the semantic convention description of the instrument
+func (ServerCallDuration) Description() string {
+	return "Measures the duration of an incoming Remote Procedure Call (RPC)."
+}
+
+// Record records val to the current distribution for attrs.
+//
+// The systemName is the the Remote Procedure Call (RPC) system.
+//
+// All additional attrs passed are included in the recorded value.
+//
+// When this metric is reported alongside an RPC server span, the metric value
+// SHOULD be the same as the RPC server span duration.
+func (m ServerCallDuration) Record(
+	ctx context.Context,
+	val float64,
+	systemName SystemNameAttr,
+	attrs ...attribute.KeyValue,
+) {
+	if len(attrs) == 0 {
+		m.Float64Histogram.Record(ctx, val, metric.WithAttributes(
+			attribute.String("rpc.system.name", string(systemName)),
+		))
+		return
+	}
+
+	o := recOptPool.Get().(*[]metric.RecordOption)
+	defer func() {
+		*o = (*o)[:0]
+		recOptPool.Put(o)
+	}()
+
+	*o = append(
+		*o,
+		metric.WithAttributes(
+			append(
+				attrs[:len(attrs):len(attrs)],
+				attribute.String("rpc.system.name", string(systemName)),
+			)...,
+		),
+	)
+
+	m.Float64Histogram.Record(ctx, val, *o...)
+}
+
+// RecordSet records val to the current distribution for set.
+//
+// When this metric is reported alongside an RPC server span, the metric value
+// SHOULD be the same as the RPC server span duration.
+func (m ServerCallDuration) RecordSet(ctx context.Context, val float64, set attribute.Set) {
+	if set.Len() == 0 {
+		m.Float64Histogram.Record(ctx, val)
+		return
+	}
+
+	o := recOptPool.Get().(*[]metric.RecordOption)
+	defer func() {
+		*o = (*o)[:0]
+		recOptPool.Put(o)
+	}()
+
+	*o = append(*o, metric.WithAttributeSet(set))
+	m.Float64Histogram.Record(ctx, val, *o...)
+}
+
+// AttrErrorType returns an optional attribute for the "error.type" semantic
+// convention. It represents the describes a class of error the operation ended
+// with.
+func (ServerCallDuration) AttrErrorType(val ErrorTypeAttr) attribute.KeyValue {
+	return attribute.String("error.type", string(val))
+}
+
+// AttrMethod returns an optional attribute for the "rpc.method" semantic
+// convention. It represents the fully-qualified logical name of the method from
+// the RPC interface perspective.
+func (ServerCallDuration) AttrMethod(val string) attribute.KeyValue {
+	return attribute.String("rpc.method", val)
+}
+
+// AttrResponseStatusCode returns an optional attribute for the
+// "rpc.response.status_code" semantic convention. It represents the status code
+// of the RPC returned by the RPC server or generated by the client.
+func (ServerCallDuration) AttrResponseStatusCode(val string) attribute.KeyValue {
+	return attribute.String("rpc.response.status_code", val)
+}
+
+// AttrServerAddress returns an optional attribute for the "server.address"
+// semantic convention. It represents a string identifying a group of RPC server
+// instances request is sent to.
+func (ServerCallDuration) AttrServerAddress(val string) attribute.KeyValue {
+	return attribute.String("server.address", val)
+}
+
+// AttrServerPort returns an optional attribute for the "server.port" semantic
+// convention. It represents the server port number.
+func (ServerCallDuration) AttrServerPort(val int) attribute.KeyValue {
+	return attribute.Int("server.port", val)
+}
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 5e9eeae8c5150..627d0e1f53336 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -584,12 +584,12 @@ go.opencensus.io/trace/tracestate
 ## explicit; go 1.24.0
 go.opentelemetry.io/auto/sdk
 go.opentelemetry.io/auto/sdk/internal/telemetry
-# go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.64.0
-## explicit; go 1.24.0
+# go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.67.0
+## explicit; go 1.25.0
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal
-# go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.64.0
-## explicit; go 1.24.0
+# go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.67.0
+## explicit; go 1.25.0
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/request
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/internal/semconv
@@ -607,17 +607,16 @@ go.opentelemetry.io/otel/internal/global
 go.opentelemetry.io/otel/propagation
 go.opentelemetry.io/otel/semconv/v1.17.0
 go.opentelemetry.io/otel/semconv/v1.37.0
-go.opentelemetry.io/otel/semconv/v1.37.0/httpconv
-go.opentelemetry.io/otel/semconv/v1.37.0/otelconv
-go.opentelemetry.io/otel/semconv/v1.37.0/rpcconv
 go.opentelemetry.io/otel/semconv/v1.40.0
+go.opentelemetry.io/otel/semconv/v1.40.0/httpconv
 go.opentelemetry.io/otel/semconv/v1.40.0/otelconv
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.39.0
-## explicit; go 1.24.0
+go.opentelemetry.io/otel/semconv/v1.40.0/rpcconv
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.42.0
+## explicit; go 1.25.0
 go.opentelemetry.io/otel/exporters/otlp/otlptrace
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.39.0
-## explicit; go 1.24.0
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.42.0
+## explicit; go 1.25.0
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/counter
@@ -626,8 +625,8 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/observ
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/otlpconfig
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/retry
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/internal/x
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.39.0
-## explicit; go 1.24.0
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.42.0
+## explicit; go 1.25.0
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/internal/counter
@@ -736,8 +735,8 @@ golang.org/x/time/rate
 # google.golang.org/genproto/googleapis/api v0.0.0-20260209200024-4cfbd4190f57
 ## explicit; go 1.24.0
 google.golang.org/genproto/googleapis/api/httpbody
-# google.golang.org/genproto/googleapis/rpc v0.0.0-20260209200024-4cfbd4190f57
-## explicit; go 1.24.0
+# google.golang.org/genproto/googleapis/rpc v0.0.0-20260226221140-a57be14db171
+## explicit; go 1.25.0
 google.golang.org/genproto/googleapis/rpc/code
 google.golang.org/genproto/googleapis/rpc/errdetails
 google.golang.org/genproto/googleapis/rpc/status