chore(instrumentation-net): update semconv usage to ATTR_ exports (#3056)

Refs: #2377

Author: trentm

packages/instrumentation-net/package.json

@@ -60,8 +60,7 @@
     "typescript": "5.0.4"
   },
   "dependencies": {
-    "@opentelemetry/instrumentation": "^0.205.0",
-    "@opentelemetry/semantic-conventions": "^1.27.0"
+    "@opentelemetry/instrumentation": "^0.205.0"
   },
   "homepage": "https://github.com/open-telemetry/opentelemetry-js-contrib/tree/main/packages/instrumentation-net#readme"
 }

packages/instrumentation-net/src/instrumentation.ts

@@ -23,14 +23,14 @@ import {
   safeExecuteInTheMiddle,
 } from '@opentelemetry/instrumentation';
 import {
-  SEMATTRS_NET_HOST_IP,
-  SEMATTRS_NET_HOST_PORT,
-  SEMATTRS_NET_PEER_IP,
-  SEMATTRS_NET_PEER_NAME,
-  SEMATTRS_NET_PEER_PORT,
-  SEMATTRS_NET_TRANSPORT,
-  NETTRANSPORTVALUES_IP_TCP,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_NET_HOST_IP,
+  ATTR_NET_HOST_PORT,
+  ATTR_NET_PEER_IP,
+  ATTR_NET_PEER_NAME,
+  ATTR_NET_PEER_PORT,
+  ATTR_NET_TRANSPORT,
+  NET_TRANSPORT_VALUE_IP_TCP,
+} from './semconv';
 import { TLSAttributes } from './types';
 import { NormalizedOptions, SocketEvent } from './internal-types';
 import { getNormalizedArgs, IPC_TRANSPORT } from './utils';
@@ -190,8 +190,8 @@ export class NetInstrumentation extends InstrumentationBase {
   private _startIpcSpan(options: NormalizedOptions, socket: Socket) {
     const span = this.tracer.startSpan('ipc.connect', {
       attributes: {
-        [SEMATTRS_NET_TRANSPORT]: IPC_TRANSPORT,
-        [SEMATTRS_NET_PEER_NAME]: options.path,
+        [ATTR_NET_TRANSPORT]: IPC_TRANSPORT,
+        [ATTR_NET_PEER_NAME]: options.path,
       },
     });
 
@@ -203,9 +203,9 @@ export class NetInstrumentation extends InstrumentationBase {
   private _startTcpSpan(options: NormalizedOptions, socket: Socket) {
     const span = this.tracer.startSpan('tcp.connect', {
       attributes: {
-        [SEMATTRS_NET_TRANSPORT]: NETTRANSPORTVALUES_IP_TCP,
-        [SEMATTRS_NET_PEER_NAME]: options.host,
-        [SEMATTRS_NET_PEER_PORT]: options.port,
+        [ATTR_NET_TRANSPORT]: NET_TRANSPORT_VALUE_IP_TCP,
+        [ATTR_NET_PEER_NAME]: options.host,
+        [ATTR_NET_PEER_PORT]: options.port,
       },
     });
 
@@ -246,9 +246,9 @@ function registerListeners(
 
   const setHostAttributes = () => {
     span.setAttributes({
-      [SEMATTRS_NET_PEER_IP]: socket.remoteAddress,
-      [SEMATTRS_NET_HOST_IP]: socket.localAddress,
-      [SEMATTRS_NET_HOST_PORT]: socket.localPort,
+      [ATTR_NET_PEER_IP]: socket.remoteAddress,
+      [ATTR_NET_HOST_IP]: socket.localAddress,
+      [ATTR_NET_HOST_PORT]: socket.localPort,
     });
   };
 

packages/instrumentation-net/src/semconv.ts

@@ -0,0 +1,101 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * This file contains a copy of unstable semantic convention definitions
+ * used by this package.
+ * @see https://github.com/open-telemetry/opentelemetry-js/tree/main/semantic-conventions#unstable-semconv
+ */
+
+/**
+ * Deprecated, use `network.local.address`.
+ *
+ * @example "192.168.0.1"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `network.local.address`.
+ */
+export const ATTR_NET_HOST_IP = 'net.host.ip' as const;
+
+/**
+ * Deprecated, use `server.port`.
+ *
+ * @example 8080
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.port`.
+ */
+export const ATTR_NET_HOST_PORT = 'net.host.port' as const;
+
+/**
+ * Deprecated, use `network.peer.address`.
+ *
+ * @example "127.0.0.1"
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `network.peer.address`.
+ */
+export const ATTR_NET_PEER_IP = 'net.peer.ip' as const;
+
+/**
+ * Deprecated, use `server.address` on client spans and `client.address` on server spans.
+ *
+ * @example example.com
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.address` on client spans and `client.address` on server spans.
+ */
+export const ATTR_NET_PEER_NAME = 'net.peer.name' as const;
+
+/**
+ * Deprecated, use `server.port` on client spans and `client.port` on server spans.
+ *
+ * @example 8080
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `server.port` on client spans and `client.port` on server spans.
+ */
+export const ATTR_NET_PEER_PORT = 'net.peer.port' as const;
+
+/**
+ * Deprecated, use `network.transport`.
+ *
+ * @experimental This attribute is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ *
+ * @deprecated Replaced by `network.transport`.
+ */
+export const ATTR_NET_TRANSPORT = 'net.transport' as const;
+
+/**
+ * Enum value "ip_tcp" for attribute {@link ATTR_NET_TRANSPORT}.
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const NET_TRANSPORT_VALUE_IP_TCP = 'ip_tcp' as const;
+
+/**
+ * Enum value "pipe" for attribute {@link ATTR_NET_TRANSPORT}.
+ *
+ * Named or anonymous pipe.
+ *
+ * @experimental This enum value is experimental and is subject to breaking changes in minor releases of `@opentelemetry/semantic-conventions`.
+ */
+export const NET_TRANSPORT_VALUE_PIPE = 'pipe' as const;

packages/instrumentation-net/src/utils.ts

@@ -15,14 +15,20 @@
  */
 
 import { NormalizedOptions } from './internal-types';
-import {
-  NETTRANSPORTVALUES_PIPE,
-  NETTRANSPORTVALUES_UNIX,
-} from '@opentelemetry/semantic-conventions';
+import { NET_TRANSPORT_VALUE_PIPE } from './semconv';
 import { platform } from 'os';
 
+// Currently the `IPC_TRANSPORT` values are for 'net.transport'. In semconv
+// v1.21.0 a breaking change (https://github.com/open-telemetry/opentelemetry-specification/pull/3426)
+// replaced 'net.transport' with 'network.transport'. The deprecated
+// 'net.transport' *removed* the 'unix' value (not sure if intentional). As a
+// result, the JS `@opentelemetry/semantic-conventions` package does not export
+// a `NET_TRANSPORT_VALUE_UNIX`.
+//
+// (TODO: update instrumentation-net (per PR-3426) to use 'network.transport',
+// then the `NETWORK_TRANSPORT_VALUE_UNIX` constant can be used.)
 export const IPC_TRANSPORT =
-  platform() === 'win32' ? NETTRANSPORTVALUES_PIPE : NETTRANSPORTVALUES_UNIX;
+  platform() === 'win32' ? NET_TRANSPORT_VALUE_PIPE : 'unix';
 
 function getHost(args: unknown[]) {
   return typeof args[1] === 'string' ? args[1] : 'localhost';

packages/instrumentation-net/test/connect.test.ts

@@ -19,7 +19,7 @@ import {
   InMemorySpanExporter,
   SimpleSpanProcessor,
 } from '@opentelemetry/sdk-trace-base';
-import { SEMATTRS_NET_TRANSPORT } from '@opentelemetry/semantic-conventions';
+import { ATTR_NET_TRANSPORT } from '../src/semconv';
 import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import * as net from 'net';
 import * as assert from 'assert';
@@ -186,10 +186,7 @@ describe('NetInstrumentation', () => {
       const assertSpan = () => {
         try {
           const span = getSpan();
-          assert.strictEqual(
-            span.attributes[SEMATTRS_NET_TRANSPORT],
-            undefined
-          );
+          assert.strictEqual(span.attributes[ATTR_NET_TRANSPORT], undefined);
           assert.strictEqual(span.status.code, SpanStatusCode.ERROR);
           done();
         } catch (e) {

packages/instrumentation-net/test/utils.ts

@@ -17,13 +17,13 @@
 import { SpanKind } from '@opentelemetry/api';
 import { ReadableSpan } from '@opentelemetry/sdk-trace-base';
 import {
-  NETTRANSPORTVALUES_IP_TCP,
-  SEMATTRS_NET_HOST_IP,
-  SEMATTRS_NET_HOST_PORT,
-  SEMATTRS_NET_PEER_NAME,
-  SEMATTRS_NET_PEER_PORT,
-  SEMATTRS_NET_TRANSPORT,
-} from '@opentelemetry/semantic-conventions';
+  ATTR_NET_HOST_IP,
+  ATTR_NET_HOST_PORT,
+  ATTR_NET_PEER_NAME,
+  ATTR_NET_PEER_PORT,
+  ATTR_NET_TRANSPORT,
+  NET_TRANSPORT_VALUE_IP_TCP,
+} from '../src/semconv';
 import * as assert from 'assert';
 import * as path from 'path';
 import * as os from 'os';
@@ -41,17 +41,17 @@ export const IPC_PATH =
 
 export function assertTcpSpan(span: ReadableSpan, socket: Socket) {
   assertSpanKind(span);
-  assertAttrib(span, SEMATTRS_NET_TRANSPORT, NETTRANSPORTVALUES_IP_TCP);
-  assertAttrib(span, SEMATTRS_NET_PEER_NAME, HOST);
-  assertAttrib(span, SEMATTRS_NET_PEER_PORT, PORT);
-  assertAttrib(span, SEMATTRS_NET_HOST_IP, socket.localAddress);
-  assertAttrib(span, SEMATTRS_NET_HOST_PORT, socket.localPort);
+  assertAttrib(span, ATTR_NET_TRANSPORT, NET_TRANSPORT_VALUE_IP_TCP);
+  assertAttrib(span, ATTR_NET_PEER_NAME, HOST);
+  assertAttrib(span, ATTR_NET_PEER_PORT, PORT);
+  assertAttrib(span, ATTR_NET_HOST_IP, socket.localAddress);
+  assertAttrib(span, ATTR_NET_HOST_PORT, socket.localPort);
 }
 
 export function assertIpcSpan(span: ReadableSpan) {
   assertSpanKind(span);
-  assertAttrib(span, SEMATTRS_NET_TRANSPORT, IPC_TRANSPORT);
-  assertAttrib(span, SEMATTRS_NET_PEER_NAME, IPC_PATH);
+  assertAttrib(span, ATTR_NET_TRANSPORT, IPC_TRANSPORT);
+  assertAttrib(span, ATTR_NET_PEER_NAME, IPC_PATH);
 }
 
 export function assertTLSSpan(
@@ -60,13 +60,13 @@ export function assertTLSSpan(
 ) {
   assertParentChild(tlsSpan, netSpan);
   assertSpanKind(netSpan);
-  assertAttrib(netSpan, SEMATTRS_NET_TRANSPORT, NETTRANSPORTVALUES_IP_TCP);
-  assertAttrib(netSpan, SEMATTRS_NET_PEER_NAME, HOST);
-  assertAttrib(netSpan, SEMATTRS_NET_PEER_PORT, PORT);
+  assertAttrib(netSpan, ATTR_NET_TRANSPORT, NET_TRANSPORT_VALUE_IP_TCP);
+  assertAttrib(netSpan, ATTR_NET_PEER_NAME, HOST);
+  assertAttrib(netSpan, ATTR_NET_PEER_PORT, PORT);
   // Node.JS 10 sets socket.localAddress & socket.localPort to "undefined" when a connection is
   // ended, so one of the tests fails, so we skip them for TLS
-  // assertAttrib(span, SEMATTRS_NET_HOST_IP, socket.localAddress);
-  //assertAttrib(netSpan, SEMATTRS_NET_HOST_PORT, socket.localPort);
+  // assertAttrib(span, ATTR_NET_HOST_IP, socket.localAddress);
+  //assertAttrib(netSpan, ATTR_NET_HOST_PORT, socket.localPort);
 
   assertAttrib(tlsSpan, TLSAttributes.PROTOCOL, 'TLSv1.2');
   assertAttrib(tlsSpan, TLSAttributes.AUTHORIZED, 'true');