refactor(shared): remove the fxa-shared/monitoring wrapper

## Because

- `fxa-shared/monitoring` is a 30-line wrapper that only calls `initTracing` then `initSentry`.
- `fxa-admin-server` already dropped the wrapper and calls both directly, so the target shape is settled.
- Every consumer already owns a small `monitoring` module, so the wrapper buys nothing.

## This pull request

- Replaces `initMonitoring` with direct `initTracing` then `initSentry` calls in `fxa-admin-panel`, `fxa-auth-server`, `fxa-customs-server` and `fxa-profile-server`. The `tracing.sentry.enabled` and `sentry.skipOpenTelemetrySetup` cross-wiring the wrapper did is kept, in the same order.
- Deletes `packages/fxa-shared/monitoring` and its `package.json` export.
- Repoints `fxa-auth-server`, `fxa-admin-panel` and `fxa-event-broker` at `@fxa/shared/otel` for tracing. Boot order in `key_server.js` does not move; only the specifier changes.
- Adds `@fxa/shared/log`, `@fxa/shared/otel` and `@fxa/shared/sentry-utils` to `fxa-event-broker/tsconfig.build.json`, whose `paths` block overrides the base one.
- Rewrites `fxa-auth-server/lib/monitoring.spec.ts` to assert the two direct calls, their order and the flag cross-wiring.

Sentry stays where it is on purpose. `fxa-shared/sentry/*` has about 30 importers and is a separate migration, so every `fxa-shared/sentry/...` import here is byte-identical to before.

## Issue that this pull request solves

Closes: https://mozilla-hub.atlassian.net/browse/FXA-10645

Partly addresses https://mozilla-hub.atlassian.net/browse/FXA-10646. See "Other information" for why `fxa-shared/tracing` cannot go yet.

Author: vbudhram

packages/fxa-admin-panel/server/config/index.ts

@@ -6,7 +6,7 @@ import convict from 'convict';
 import fs from 'fs';
 import path from 'path';
 import { GuardConfig } from '@fxa/shared/guards';
-import { tracingConfig } from 'fxa-shared/tracing/config';
+import { tracingConfig } from '@fxa/shared/otel';
 
 convict.addFormats(require('convict-format-with-moment'));
 convict.addFormats(require('convict-format-with-validator'));

packages/fxa-admin-panel/server/lib/monitoring.ts

@@ -4,15 +4,24 @@
 
 import Config from '../config';
 import mozLog from 'mozlog';
-import { initMonitoring } from 'fxa-shared/monitoring';
+import { TracingOpts, initTracing } from '@fxa/shared/otel';
+import { InitSentryOpts, initSentry } from 'fxa-shared/sentry/node';
 import { version } from '../../package.json';
 
-const config = Config.getProperties();
-const log = mozLog(config.logging)(config.logging.app);
-initMonitoring({
-  log,
-  config: {
-    ...config,
-    release: version,
-  },
-});
+const properties = Config.getProperties();
+const log = mozLog(properties.logging)(properties.logging.app);
+
+const config: InitSentryOpts & { tracing: TracingOpts } = {
+  ...properties,
+  release: version,
+};
+
+// Sentry also uses OTEL under the hood. Tracing must start first, and each side
+// must know about the other, or traces and breadcrumbs bleed between requests.
+if (config.sentry?.dsn) {
+  config.tracing.sentry = { enabled: true };
+}
+if (initTracing(config.tracing, log) && config.sentry) {
+  config.sentry.skipOpenTelemetrySetup = true;
+}
+initSentry(config, log);

packages/fxa-auth-server/bin/key_server.js

@@ -30,7 +30,7 @@ const {
   ProductConfigurationManager,
   StrapiClient,
 } = require('@fxa/shared/cms');
-const TracingProvider = require('fxa-shared/tracing/node-tracing');
+const TracingProvider = require('@fxa/shared/otel');
 
 const { createNoopStatsd } = require('../lib/noop-statsd');
 const { AppError: error } = require('@fxa/accounts/errors');

packages/fxa-auth-server/config/index.ts

@@ -4,7 +4,7 @@
 import convict from 'convict';
 import fs from 'fs';
 import { makeRedisConfig } from 'fxa-shared/db/config';
-import { tracingConfig } from 'fxa-shared/tracing/config';
+import { tracingConfig } from '@fxa/shared/otel';
 import { CloudTasksConvictConfigFactory } from '@fxa/shared/cloud-tasks';
 import path from 'path';
 import url from 'url';

packages/fxa-auth-server/lib/monitoring.js

@@ -2,23 +2,27 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-const { initMonitoring } = require('fxa-shared/monitoring');
+const { initTracing } = require('@fxa/shared/otel');
+const { initSentry } = require('fxa-shared/sentry/node');
 const Sentry = require('@sentry/node');
-const { config } = require('../config');
-const logger = require('./log')(
-  config.getProperties().log.level,
-  'configure-sentry'
-);
+const { config: convictConfig } = require('../config');
+const config = convictConfig.getProperties();
 const { version } = require('../package.json');
 const { ignoreErrors } = require('@fxa/accounts/errors');
 
-/**
- * Initialize sentry & otel
- */
-initMonitoring({
-  logger,
-  config: {
-    ...config.getProperties(),
+const logger = require('./log')(config.log.level, 'configure-sentry');
+
+// Sentry also uses OTEL under the hood. Tracing must start first, and each side
+// must know about the other, or traces and breadcrumbs bleed between requests.
+if (config.sentry?.dsn) {
+  config.tracing.sentry = { enabled: true };
+}
+if (initTracing(config.tracing, logger)) {
+  config.sentry.skipOpenTelemetrySetup = true;
+}
+initSentry(
+  {
+    ...config,
     release: version,
     eventFilters: [filterSentryEvent],
     integrations: [
@@ -27,7 +31,8 @@ initMonitoring({
       Sentry.linkedErrorsIntegration({ key: 'jse_cause' }),
     ],
   },
-});
+  logger
+);
 
 /**
  * Filter a sentry event for PII in addition to the default filters.

packages/fxa-auth-server/lib/monitoring.spec.ts

@@ -2,7 +2,8 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-const mockInitMonitoring = jest.fn();
+const mockInitTracing = jest.fn().mockReturnValue({});
+const mockInitSentry = jest.fn();
 const mockIgnoreErrors = jest.fn();
 const mockLogger = {
   info: jest.fn(),
@@ -17,14 +18,18 @@ const mockLinkedErrorsIntegration = jest
   .fn()
   .mockReturnValue({ name: 'LinkedErrors' });
 
-jest.mock('fxa-shared/monitoring', () => ({
-  initMonitoring: mockInitMonitoring,
+jest.mock('@fxa/shared/otel', () => ({
+  initTracing: mockInitTracing,
+}));
+jest.mock('fxa-shared/sentry/node', () => ({
+  initSentry: mockInitSentry,
 }));
 jest.mock('../config', () => ({
   config: {
     getProperties: jest.fn().mockReturnValue({
       log: { level: 'debug' },
       sentry: { dsn: 'https://test@sentry.io/123' },
+      tracing: { serviceName: 'fxa-auth-server' },
     }),
   },
 }));
@@ -40,20 +45,23 @@ jest.mock('@sentry/node', () => ({
   linkedErrorsIntegration: mockLinkedErrorsIntegration,
 }));
 
-// Importing the module triggers the top-level initMonitoring() call once.
+// Importing the module triggers the top-level init calls once.
 import './monitoring';
 
 // Snapshot one-shot call args before `clearMocks: true` wipes them
 // between tests; the module-load side-effect can't be replayed.
-const initMonitoringCallCount = mockInitMonitoring.mock.calls.length;
-const initMonitoringArg = mockInitMonitoring.mock.calls[0]?.[0];
+const initTracingCalls = mockInitTracing.mock.calls.map((c) => [...c]);
+const initSentryCalls = mockInitSentry.mock.calls.map((c) => [...c]);
+const initSentryConfig = initSentryCalls[0]?.[0];
+const tracingCallOrder = mockInitTracing.mock.invocationCallOrder[0];
+const sentryCallOrder = mockInitSentry.mock.invocationCallOrder[0];
 const hapiIntegrationCallCount = mockHapiIntegration.mock.calls.length;
 const linkedErrorsIntegrationCalls = mockLinkedErrorsIntegration.mock.calls.map(
   (c) => c[0]
 );
 const logCalls = mockLog.mock.calls.map((c) => [...c]);
 const filterSentryEvent: (event: any, hint?: any) => any =
-  initMonitoringArg.config.eventFilters[0];
+  initSentryConfig.eventFilters[0];
 
 describe('monitoring', () => {
   beforeEach(() => {
@@ -64,24 +72,37 @@ describe('monitoring', () => {
     jest.restoreAllMocks();
   });
 
-  it('calls initMonitoring on module load', () => {
-    expect(initMonitoringCallCount).toBe(1);
+  it('initializes tracing before sentry on module load', () => {
+    expect(initTracingCalls).toHaveLength(1);
+    expect(initSentryCalls).toHaveLength(1);
+    expect(tracingCallOrder).toBeLessThan(sentryCallOrder);
 
-    // Logger is the return value of the mocked log(level, name)
-    expect(initMonitoringArg.logger).toBe(mockLogger);
+    // Both get the return value of the mocked log(level, name)
+    expect(initTracingCalls[0][1]).toBe(mockLogger);
+    expect(initSentryCalls[0][1]).toBe(mockLogger);
     expect(logCalls).toContainEqual(['debug', 'configure-sentry']);
+  });
+
+  it('cross-wires the sentry and otel flags', () => {
+    // A sentry dsn tells otel that sentry is present...
+    expect(initTracingCalls[0][0]).toEqual({
+      serviceName: 'fxa-auth-server',
+      sentry: { enabled: true },
+    });
+    // ...and a live tracer tells sentry to skip its own otel setup.
+    expect(initSentryConfig.sentry.skipOpenTelemetrySetup).toBe(true);
+  });
 
-    // Config includes spread properties, release, eventFilters, integrations
-    expect(initMonitoringArg.config).toEqual(
+  it('passes the spread config, release, eventFilters and integrations', () => {
+    expect(initSentryConfig).toEqual(
       expect.objectContaining({
         log: { level: 'debug' },
-        sentry: { dsn: 'https://test@sentry.io/123' },
         release: '1.234.0',
       })
     );
-    expect(initMonitoringArg.config.eventFilters).toHaveLength(1);
-    expect(typeof initMonitoringArg.config.eventFilters[0]).toBe('function');
-    expect(initMonitoringArg.config.integrations).toHaveLength(2);
+    expect(initSentryConfig.eventFilters).toHaveLength(1);
+    expect(typeof initSentryConfig.eventFilters[0]).toBe('function');
+    expect(initSentryConfig.integrations).toHaveLength(2);
   });
 
   it('passes Sentry integrations with correct configuration', () => {

packages/fxa-auth-server/lib/routes/index.js

@@ -5,7 +5,7 @@
 'use strict';
 
 const url = require('url');
-const tracing = require('fxa-shared/tracing/node-tracing');
+const tracing = require('@fxa/shared/otel');
 
 module.exports = function (
   log,

packages/fxa-customs-server/lib/monitoring.js

@@ -3,16 +3,26 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 const Sentry = require('@sentry/node');
-const { initMonitoring } = require('fxa-shared/monitoring');
+const { initTracing } = require('fxa-shared/tracing/node-tracing');
+const { initSentry } = require('fxa-shared/sentry/node');
+const { version } = require('../package.json');
+
 const config = require('./config').getProperties();
 const log = require('./log')(config.log.level, 'configure-sentry');
-const { version } = require('../package.json');
 
-initMonitoring({
-  log,
-  config: {
+// Sentry also uses OTEL under the hood. Tracing must start first, and each side
+// must know about the other, or traces and breadcrumbs bleed between requests.
+if (config.sentry?.dsn) {
+  config.tracing.sentry = { enabled: true };
+}
+if (initTracing(config.tracing, log)) {
+  config.sentry.skipOpenTelemetrySetup = true;
+}
+initSentry(
+  {
     ...config,
     release: version,
     integrations: [Sentry.linkedErrorsIntegration({ key: 'jse_cause' })],
   },
-});
+  log
+);

packages/fxa-event-broker/src/config.ts

@@ -5,7 +5,7 @@
 import convict from 'convict';
 import fs from 'fs';
 import path from 'path';
-import { tracingConfig } from 'fxa-shared/tracing/config';
+import { tracingConfig } from '@fxa/shared/otel';
 
 const FIVE_MINUTES = 60 * 5;
 

packages/fxa-event-broker/src/main.ts

@@ -13,7 +13,7 @@ import { ConfigService } from '@nestjs/config';
 import { NestFactory } from '@nestjs/core';
 import mozLog from 'mozlog';
 
-import { initTracing } from 'fxa-shared/tracing/node-tracing';
+import { initTracing } from '@fxa/shared/otel';
 
 import { AppModule } from './app.module';
 import Config, { AppConfig } from './config';