@multiplayer-app/session-recorder-node 1.2.1 → 1.2.3

package/examples/http-server/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "http-server-exmaple",
+    "version": "1.0.0",
+    "description": "",
+    "main": "./src/index.ts",
+    "engines": {
+        "node": ">=18",
+        "npm": ">=8"
+    },
+    "scripts": {
+        "start": "node dist/index.js",
+        "dev": "nodemon --watch \"src/**\" --ext \"ts,json\" --ignore \"src/**/*.spec.ts\" --exec \"ts-node src/index.ts\"",
+        "build": "npm run clean && npm run compile",
+        "clean": "rm -rf ./dist",
+        "compile": "tsc --build --force",
+        "lint": "eslint src/**/*.ts --config ../../.eslintrc"
+    },
+    "author": "Multiplayer",
+    "dependencies": {
+        "@multiplayer-app/session-recorder-node": "1.2.2",
+        "@opentelemetry/api": "1.9.0",
+        "@opentelemetry/api-logs": "0.203.0",
+        "@opentelemetry/auto-instrumentations-node": "0.62.1",
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/exporter-trace-otlp-http": "0.203.0",
+        "@opentelemetry/exporter-logs-otlp-http": "0.203.0",
+        "@opentelemetry/resources": "2.0.1",
+        "@opentelemetry/sdk-logs": "0.203.0",
+        "@opentelemetry/sdk-trace-base": "2.0.1",
+        "@opentelemetry/sdk-trace-node": "2.0.1",
+        "@opentelemetry/semantic-conventions": "1.36.0",
+        "body-parser": "1.20.2",
+        "cors": "2.8.5",
+        "dotenv": "16.3.1",
+        "express": "4.18.2"
+    },
+    "devDependencies": {
+        "@types/body-parser": "1.19.2",
+        "@types/cors": "2.8.13",
+        "@types/express": "4.17.17",
+        "@types/jest": "29.5.4",
+        "@types/node": "20.5.7",
+        "eslint": "8.48.0",
+        "nodemon": "3.1.9",
+        "ts-node": "10.9.1",
+        "typescript": "5.7.3"
+    }
+}

package/examples/http-server/src/api.ts

@@ -0,0 +1,20 @@
+import express, {
+  type Request,
+  type Response,
+  type NextFunction
+} from 'express'
+
+const { Router } = express
+const router = Router()
+
+const health = async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    return res.status(200).json({})
+  } catch (err) {
+    return next(err)
+  }
+}
+
+router.route('/').get(health)
+
+export default router

package/examples/http-server/src/config.ts

@@ -0,0 +1,24 @@
+export const NODE_ENV = process.env.NODE_ENV || 'development'
+export const isProduction = NODE_ENV === 'production'
+
+export const PORT = Number(process.env.PORT || 3000)
+export const API_PREFIX = process.env.API_PREFIX || '/v1/api'
+
+export const LOG_LEVEL = process.env.LOG_LEVEL || (isProduction ? 'info' : 'debug')
+
+export const COMPONENT_NAME = process.env.npm_package_name?.split('/').pop() as string || process.env.SERVICE_NAME || 'timegate'
+export const COMPONENT_VERSION = process.env.npm_package_version || '0.0.1'
+export const ENVIRONMENT = process.env.ENVIRONMENT || 'staging'
+
+export const MULTIPLAYER_OTLP_KEY = process.env.MULTIPLAYER_OTLP_KEY as string
+
+if (!MULTIPLAYER_OTLP_KEY) {
+  throw new Error('MULTIPLAYER_OTLP_KEY is not set')
+}
+
+export const OTLP_TRACES_ENDPOINT = process.env.OTLP_TRACES_ENDPOINT || 'https://api.multiplayer.app/v1/traces'
+export const OTLP_LOGS_ENDPOINT = process.env.OTLP_LOGS_ENDPOINT || 'https://api.multiplayer.app/v1/logs'
+
+export const MULTIPLAYER_OTLP_SPAN_RATIO = process.env.MULTIPLAYER_OTLP_SPAN_RATIO
+  ? Number(process.env.MULTIPLAYER_OTLP_SPAN_RATIO)
+  : 0.01

package/examples/http-server/src/index.ts

@@ -0,0 +1,46 @@
+import 'dotenv/config'
+import './opentelemetry'
+import http from 'http'
+import cors from 'cors'
+import bodyParser from 'body-parser'
+import express, {
+    type Request,
+    type Response,
+    type NextFunction,
+} from 'express'
+import { PORT, API_PREFIX } from './config'
+import api from './api'
+
+const app = express()
+
+app.use(cors())
+app.use(bodyParser.urlencoded({ extended: true }))
+app.use(bodyParser.json())
+
+app.use(API_PREFIX, api)
+
+app.use((req: Request, res: Response, next: NextFunction) => {
+    res.status(404).send('Not found')
+  })
+
+const httpServer = http.createServer(app)
+const onReady = () => {
+    console.log(`🚀 Server ready at http://localhost:${PORT}`)
+}
+
+httpServer.listen(PORT, onReady)
+
+const exitHandler = async (error: Error) => {
+    if (error) {
+        console.log('Server exited with error', error)
+    }
+    process.removeListener('exit', exitHandler)
+    process.exit()
+}
+
+process.on('exit', exitHandler)
+process.on('SIGINT', exitHandler)
+process.on('SIGTERM', exitHandler)
+process.on('uncaughtException', (err) => {
+    console.error('uncaughtException', err)
+})

package/examples/http-server/src/opentelemetry.ts

@@ -0,0 +1,140 @@
+import { hostname } from 'os'
+import { node, NodeSDK } from '@opentelemetry/sdk-node'
+import {
+  BatchSpanProcessor,
+  ParentBasedSampler,
+} from '@opentelemetry/sdk-trace-base'
+import {
+  getNodeAutoInstrumentations,
+  getResourceDetectors,
+} from '@opentelemetry/auto-instrumentations-node'
+import {
+  resourceFromAttributes,
+  detectResources,
+} from '@opentelemetry/resources'
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+  SEMRESATTRS_HOST_NAME,
+  SEMRESATTRS_DEPLOYMENT_ENVIRONMENT,
+  SEMRESATTRS_PROCESS_RUNTIME_VERSION,
+  SEMRESATTRS_PROCESS_PID,
+} from '@opentelemetry/semantic-conventions'
+import api from '@opentelemetry/api'
+// import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http"
+import { W3CTraceContextPropagator } from '@opentelemetry/core'
+import {
+  SessionRecorderHttpInstrumentationHooksNode,
+  SessionRecorderTraceIdRatioBasedSampler,
+  SessionRecorderIdGenerator,
+  SessionRecorderHttpTraceExporter,
+  SessionRecorderHttpLogsExporter,
+} from '@multiplayer-app/session-recorder-node'
+import { LoggerProvider, BatchLogRecordProcessor } from '@opentelemetry/sdk-logs'
+import * as apiLogs from '@opentelemetry/api-logs'
+// import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http'
+
+import {
+  OTLP_TRACES_ENDPOINT,
+  OTLP_LOGS_ENDPOINT,
+  MULTIPLAYER_OTLP_KEY,
+  MULTIPLAYER_OTLP_SPAN_RATIO,
+  COMPONENT_NAME,
+  COMPONENT_VERSION,
+  ENVIRONMENT,
+} from './config'
+
+// NOTE: Update instrumentation configuration as needed
+// For more see: https://www.npmjs.com/package/@opentelemetry/auto-instrumentations-node
+const instrumentations = [
+  getNodeAutoInstrumentations({
+    '@opentelemetry/instrumentation-http': {
+      requestHook: SessionRecorderHttpInstrumentationHooksNode.requestHook({
+        maskHeadersList: ['X-Api-Key'],
+        maxPayloadSizeBytes: 5000,
+        schemifyDocSpanPayload: false,
+        isMaskBodyEnabled: false,
+      }),
+      responseHook: SessionRecorderHttpInstrumentationHooksNode.responseHook({
+        maskHeadersList: ['X-Api-Key'],
+        maxPayloadSizeBytes: 5000,
+        schemifyDocSpanPayload: false,
+        isMaskBodyEnabled: false,
+      }),
+    },
+  }),
+]
+
+const getResource = () => {
+  const resourceWithAttributes = resourceFromAttributes({
+    [ATTR_SERVICE_NAME]: COMPONENT_NAME,
+    [ATTR_SERVICE_VERSION]: COMPONENT_VERSION,
+    [SEMRESATTRS_HOST_NAME]: hostname(),
+    [SEMRESATTRS_DEPLOYMENT_ENVIRONMENT]: ENVIRONMENT,
+    [SEMRESATTRS_PROCESS_RUNTIME_VERSION]: process.version,
+    [SEMRESATTRS_PROCESS_PID]: process.pid,
+  })
+  const detectedResources = detectResources({ detectors: getResourceDetectors() })
+  const resource = resourceWithAttributes.merge(detectedResources)
+
+  return resource
+}
+
+export const idGenerator = new SessionRecorderIdGenerator()
+
+const opentelemetry = () => {
+  // const traceExporter = new OTLPTraceExporter({
+  //   url: OTLP_TRACES_ENDPOINT,
+  //   headers: {
+  //     Authorization: MULTIPLAYER_OTLP_KEY
+  //   },
+  // })
+  const traceExporter = new SessionRecorderHttpTraceExporter({
+    apiKey: MULTIPLAYER_OTLP_KEY,
+    url: OTLP_TRACES_ENDPOINT,
+  })
+
+  const resource = getResource()
+
+  const provider = new node.NodeTracerProvider({
+    resource,
+    spanProcessors: [
+      new BatchSpanProcessor(traceExporter),
+    ],
+    sampler: new ParentBasedSampler({
+      root: new SessionRecorderTraceIdRatioBasedSampler(MULTIPLAYER_OTLP_SPAN_RATIO),
+    }),
+    idGenerator,
+  })
+
+  // const logExporter = new OTLPLogExporter({
+  //   url: OTLP_LOGS_ENDPOINT,
+  //   headers: {
+  //     Authorization: MULTIPLAYER_OTLP_KEY
+  //   },
+  // })
+  const logExporter = new SessionRecorderHttpLogsExporter({
+    apiKey: MULTIPLAYER_OTLP_KEY,
+    url: OTLP_LOGS_ENDPOINT,
+  })
+  const logRecordProcessor = new BatchLogRecordProcessor(logExporter)
+
+  const loggerProvider = new LoggerProvider({
+    resource,
+    processors: [logRecordProcessor],
+  })
+
+  apiLogs.logs.setGlobalLoggerProvider(loggerProvider)
+
+  provider.register()
+  api.trace.setGlobalTracerProvider(provider)
+  api.propagation.setGlobalPropagator(new W3CTraceContextPropagator())
+
+  const sdk = new NodeSDK({
+    instrumentations,
+  })
+
+  sdk.start()
+}
+
+opentelemetry()

package/examples/http-server/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "baseUrl": ".",
+    "module": "commonjs",
+    "noImplicitAny": false,
+    "noUnusedParameters": false,
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "moduleResolution": "node",
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": false,
+    "preserveConstEnums": true,
+    "removeComments": false,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "target": "ES2018",
+    "downlevelIteration": true,
+    "strict": true,
+    "composite": true,
+    "outDir": "./dist/",
+    "rootDir": "./src/",
+    "preserveSymlinks": true
+  },
+  "exclude": ["dist", "coverage", "jest.config.js", "__tests__", "migration"],
+  "references": [],
+  "ts-node": {
+    "files": true
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplayer-app/session-recorder-node",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Multiplayer Fullstack Session Recorder for Node.js",
   "author": {
     "name": "Multiplayer Software, Inc.",
@@ -29,7 +29,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@multiplayer-app/session-recorder-common": "1.2.1",
+    "@multiplayer-app/session-recorder-common": "1.2.3",
     "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/core": "^2.0.1",
     "@opentelemetry/otlp-exporter-base": "^0.203.0",

package/src/sessionRecorder.ts

@@ -116,6 +116,10 @@ export class SessionRecorder {
       session = await this._apiService.startSession(sessionPayload)
     }
 
+    if (!session?.shortId) {
+      throw new Error('Failed to start session')
+    }
+
     this._shortSessionId = session.shortId as string
 
     (this._traceIdGenerator as SessionRecorderIdGenerator).setSessionId(

package/tsconfig.json

@@ -26,10 +26,10 @@
     "strict": true,
     "composite": true,
     "outDir": "./dist/",
-    "rootDir": "./src",
+    "rootDir": "./src/",
     "preserveSymlinks": true,
     "paths": {}
   },
-  "exclude": ["dist"],
+  "exclude": ["dist", "examples"],
   "references": []
 }