feat: collect additional process attributes (open-telemetry#3605)

* refactor: move ProcessDetector to node; export noopDetector for Browser

* feat: collect additional process attributes

* refactor: always return a process resource

This commit introduces a slight change in behavior. Previously the
ProcessDectector would validate that it received attributes that it
expected, and returned an empty Resource if it didn't. Based on the
types, and the implementation of the ProcessDetector, there will
always be a valid ProcessResource. Collection of many of the attributes
can be done as a best effort without violating the specification.

* chore: add changelog entry

* feat: collect process.execArgv in process.command_args

* refactor: omit process.command_line in favor of process.command_args

* Move changelog entry to unreleased

---------

Co-authored-by: Daniel Dyla <dyladan@users.noreply.github.com>
Co-authored-by: Marc Pichler <marc.pichler@dynatrace.com>

CHANGELOG.md

@@ -12,6 +12,7 @@ For experimental package changes, see the [experimental CHANGELOG](experimental/
 ### :rocket: (Enhancement)
 
 * feat(sdk-metrics): add exponential histogram accumulation / aggregator [#3505](https://github.com/open-telemetry/opentelemetry-js/pull/3505) @mwear
+* feat(resources): collect additional process attributes [#3605](https://github.com/open-telemetry/opentelemetry-js/pull/3605) @mwear
 
 ### :bug: (Bug Fix)
 

packages/opentelemetry-resources/src/detectors/index.ts

@@ -16,7 +16,5 @@
 
 export * from './BrowserDetector';
 export * from './EnvDetector';
-export * from './ProcessDetector';
 export * from './BrowserDetectorSync';
 export * from './EnvDetectorSync';
-export * from './ProcessDetectorSync';

packages/opentelemetry-resources/src/platform/browser/ProcessDetector.ts

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+
+import { noopDetector } from '../../detectors/NoopDetector';
+
+export const processDetector = noopDetector;

packages/opentelemetry-resources/src/platform/browser/ProcessDetectorSync.ts

@@ -0,0 +1,19 @@
+/*
+ * 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.
+ */
+
+import { noopDetector } from '../../detectors/NoopDetector';
+
+export const processDetectorSync = noopDetector;

packages/opentelemetry-resources/src/platform/browser/index.ts

@@ -19,3 +19,5 @@ export * from './HostDetector';
 export * from './OSDetector';
 export * from './HostDetectorSync';
 export * from './OSDetectorSync';
+export * from './ProcessDetector';
+export * from './ProcessDetectorSync';

packages/opentelemetry-resources/src/detectors/ProcessDetector.ts → packages/opentelemetry-resources/src/platform/node/ProcessDetector.ts

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-import { Detector } from '../types';
-import { ResourceDetectionConfig } from '../config';
-import { IResource } from '../IResource';
+import { Detector } from '../../types';
+import { ResourceDetectionConfig } from '../../config';
+import { IResource } from '../../IResource';
 import { processDetectorSync } from './ProcessDetectorSync';
 
 /**

packages/opentelemetry-resources/src/platform/node/ProcessDetectorSync.ts

@@ -0,0 +1,61 @@
+/*
+ * 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.
+ */
+
+import { diag } from '@opentelemetry/api';
+import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions';
+import { Resource } from '../../Resource';
+import { DetectorSync, ResourceAttributes } from '../../types';
+import { ResourceDetectionConfig } from '../../config';
+import { IResource } from '../../IResource';
+import * as os from 'os';
+
+/**
+ * ProcessDetectorSync will be used to detect the resources related current process running
+ * and being instrumented from the NodeJS Process module.
+ */
+class ProcessDetectorSync implements DetectorSync {
+  detect(_config?: ResourceDetectionConfig): IResource {
+    const attributes: ResourceAttributes = {
+      [SemanticResourceAttributes.PROCESS_PID]: process.pid,
+      [SemanticResourceAttributes.PROCESS_EXECUTABLE_NAME]: process.title,
+      [SemanticResourceAttributes.PROCESS_EXECUTABLE_PATH]: process.execPath,
+      [SemanticResourceAttributes.PROCESS_COMMAND_ARGS]: [
+        process.argv[0],
+        ...process.execArgv,
+        ...process.argv.slice(1),
+      ],
+      [SemanticResourceAttributes.PROCESS_RUNTIME_VERSION]:
+        process.versions.node,
+      [SemanticResourceAttributes.PROCESS_RUNTIME_NAME]: 'nodejs',
+      [SemanticResourceAttributes.PROCESS_RUNTIME_DESCRIPTION]: 'Node.js',
+    };
+
+    if (process.argv.length > 1) {
+      attributes[SemanticResourceAttributes.PROCESS_COMMAND] = process.argv[1];
+    }
+
+    try {
+      const userInfo = os.userInfo();
+      attributes[SemanticResourceAttributes.PROCESS_OWNER] = userInfo.username;
+    } catch (e) {
+      diag.debug(`error obtaining process owner: ${e}`);
+    }
+
+    return new Resource(attributes);
+  }
+}
+
+export const processDetectorSync = new ProcessDetectorSync();

packages/opentelemetry-resources/src/platform/node/index.ts

@@ -19,3 +19,5 @@ export * from './HostDetector';
 export * from './OSDetector';
 export * from './HostDetectorSync';
 export * from './OSDetectorSync';
+export * from './ProcessDetector';
+export * from './ProcessDetectorSync';

packages/opentelemetry-resources/test/detectors/node/ProcessDetector.test.ts

@@ -15,41 +15,59 @@
  */
 import * as sinon from 'sinon';
 import { processDetector, IResource } from '../../../src';
-import {
-  assertResource,
-  assertEmptyResource,
-} from '../../util/resource-assertions';
+import { assertResource } from '../../util/resource-assertions';
 import { describeNode } from '../../util';
+import * as os from 'os';
 
 describeNode('processDetector() on Node.js', () => {
   afterEach(() => {
     sinon.restore();
   });
 
   it('should return resource information from process', async () => {
+    const argv = ['/tmp/node', '/home/ot/test.js', 'arg1', 'arg2'];
     sinon.stub(process, 'pid').value(1234);
     sinon.stub(process, 'title').value('otProcess');
-    sinon
-      .stub(process, 'argv')
-      .value(['/tmp/node', '/home/ot/test.js', 'arg1', 'arg2']);
+    sinon.stub(process, 'argv').value(argv);
+    sinon.stub(process, 'execPath').value(argv[0]);
+    sinon.stub(process, 'execArgv').value(['--trace-warnings']);
     sinon.stub(process, 'versions').value({ node: '1.4.1' });
+    sinon
+      .stub(os, 'userInfo')
+      .returns({ username: 'appOwner' } as os.UserInfo<string>);
 
     const resource: IResource = await processDetector.detect();
     assertResource(resource, {
       pid: 1234,
       name: 'otProcess',
       command: '/home/ot/test.js',
-      commandLine: '/tmp/node /home/ot/test.js arg1 arg2',
+      commandArgs: [
+        '/tmp/node',
+        '--trace-warnings',
+        '/home/ot/test.js',
+        'arg1',
+        'arg2',
+      ],
+      executablePath: argv[0],
+      owner: 'appOwner',
       version: '1.4.1',
       runtimeDescription: 'Node.js',
       runtimeName: 'nodejs',
     });
   });
-  it('should return empty resources if title, command and commondLine is missing', async () => {
+
+  it('should return a resources if title, command and commandLine are missing', async () => {
     sinon.stub(process, 'pid').value(1234);
-    sinon.stub(process, 'title').value(undefined);
+    sinon.stub(process, 'title').value('');
     sinon.stub(process, 'argv').value([]);
+    sinon.stub(process, 'versions').value({ node: '1.4.1' });
     const resource: IResource = await processDetector.detect();
-    assertEmptyResource(resource);
+    // at a minium we should be able to rely on pid runtime, runtime name, and description
+    assertResource(resource, {
+      pid: 1234,
+      version: '1.4.1',
+      runtimeDescription: 'Node.js',
+      runtimeName: 'nodejs',
+    });
   });
 });

packages/opentelemetry-resources/test/util/resource-assertions.ts

@@ -269,7 +269,9 @@ export const assertResource = (
     pid?: number;
     name?: string;
     command?: string;
-    commandLine?: string;
+    commandArgs?: string[];
+    executablePath?: string;
+    owner?: string;
     version?: string;
     runtimeName?: string;
     runtimeDescription?: string;
@@ -291,10 +293,22 @@ export const assertResource = (
       validations.command
     );
   }
-  if (validations.commandLine) {
+  if (validations.commandArgs) {
+    assert.deepStrictEqual(
+      resource.attributes[SemanticResourceAttributes.PROCESS_COMMAND_ARGS],
+      validations.commandArgs
+    );
+  }
+  if (validations.executablePath) {
+    assert.strictEqual(
+      resource.attributes[SemanticResourceAttributes.PROCESS_EXECUTABLE_PATH],
+      validations.executablePath
+    );
+  }
+  if (validations.owner) {
     assert.strictEqual(
-      resource.attributes[SemanticResourceAttributes.PROCESS_COMMAND_LINE],
-      validations.commandLine
+      resource.attributes[SemanticResourceAttributes.PROCESS_OWNER],
+      validations.owner
     );
   }
   if (validations.version) {