Merge branch 'main' of github.com:grafana/pyroscope-nodejs into remov…

…e-package-lock.json

.eslintrc.js

@@ -8,4 +8,4 @@ module.exports = {
     'prettier/prettier': 'error',
   },
   plugins: ['@typescript-eslint', 'prettier'],
-}
+};

.prettierrc.js

@@ -1,7 +1,7 @@
 module.exports = {
-  semi: false,
+  semi: true,
   singleQuote: true,
   trailingComma: 'es5',
   arrowParens: 'always',
   printWidth: 80,
-}
+};

CODEOWNERS

@@ -1 +1 @@
-* @grafana/pyroscope-nodejs
+* @grafana/pyroscope-nodejs @grafana/pyroscope-team

config/fileTransformer.js

@@ -1,9 +1,9 @@
 // source: https://jestjs.io/docs/code-transformation#examples
 
-import 'path'
+import 'path';
 
 module.exports = {
   process(src, filename) {
-    return 'module.exports = ' + JSON.stringify(path.basename(filename)) + ';'
+    return 'module.exports = ' + JSON.stringify(path.basename(filename)) + ';';
   },
-}
+};

config/webpack.config.js

@@ -1,4 +1,4 @@
-import 'path'
+import 'path';
 
 module.exports = {
   mode: 'production',
@@ -27,4 +27,4 @@ module.exports = {
   resolve: {
     extensions: ['.ts', '.js', '.tsx', '.jsx'],
   },
-}
+};

jest.config.js

@@ -18,4 +18,4 @@ module.exports = {
     },
   },
   extensionsToTreatAsEsm: ['.ts'],
-}
+};

src/environment.ts

@@ -1,12 +1,12 @@
 export interface Environment {
-  adhocServerAddress: string | undefined
-  appName: string | undefined
-  authToken: string | undefined
-  flushIntervalMs: number | undefined
-  heapSamplingIntervalBytes: number | undefined
-  heapStackDepth: number | undefined
-  serverAddress: string | undefined
-  wallSamplingDurationMs: number | undefined
-  wallSamplingIntervalMicros: number | undefined
-  wallCollectCpuTime: boolean | undefined
+  adhocServerAddress: string | undefined;
+  appName: string | undefined;
+  authToken: string | undefined;
+  flushIntervalMs: number | undefined;
+  heapSamplingIntervalBytes: number | undefined;
+  heapStackDepth: number | undefined;
+  serverAddress: string | undefined;
+  wallSamplingDurationMs: number | undefined;
+  wallSamplingIntervalMicros: number | undefined;
+  wallCollectCpuTime: boolean | undefined;
 }

src/express/middleware.ts

@@ -1,65 +1,65 @@
-import debug from 'debug'
-import { NextFunction, Request, Response, RequestHandler } from 'express'
-import { Profile } from 'pprof-format'
-import { Profiler } from '../profilers/profiler'
-import { PyroscopeProfiler } from '../profilers/pyroscope-profiler'
-import { WallProfilerStartArgs } from '../profilers/wall-profiler'
-import { getProfiler } from '../utils/pyroscope-profiler'
-import { encode } from '@datadog/pprof'
-import { HeapProfilerStartArgs } from '../profilers/heap-profiler'
-
-const log = debug('pyroscope')
+import debug from 'debug';
+import { NextFunction, Request, Response, RequestHandler } from 'express';
+import { Profile } from 'pprof-format';
+import { Profiler } from '../profilers/profiler';
+import { PyroscopeProfiler } from '../profilers/pyroscope-profiler';
+import { WallProfilerStartArgs } from '../profilers/wall-profiler';
+import { getProfiler } from '../utils/pyroscope-profiler';
+import { encode } from '@datadog/pprof';
+import { HeapProfilerStartArgs } from '../profilers/heap-profiler';
+
+const log = debug('pyroscope');
 
 async function collectProfile<TStartArgs>(
   profiler: Profiler<TStartArgs>
 ): Promise<Buffer> {
-  const profile: Profile = profiler.profile().profile
+  const profile: Profile = profiler.profile().profile;
 
-  profiler.stop()
+  profiler.stop();
 
-  return encode(profile)
+  return encode(profile);
 }
 
 async function collectProfileAfterMs<TStartArgs>(
   profiler: Profiler<TStartArgs>,
   args: TStartArgs,
   delayMs: number
 ): Promise<Buffer> {
-  profiler.start(args)
+  profiler.start(args);
 
   if (delayMs === 0) {
-    return collectProfile(profiler)
+    return collectProfile(profiler);
   }
 
   return new Promise(
     (resolve: (buffer: Buffer | PromiseLike<Buffer>) => void) => {
       setTimeout(() => {
-        resolve(collectProfile(profiler))
-      }, delayMs)
+        resolve(collectProfile(profiler));
+      }, delayMs);
     }
-  )
+  );
 }
 
 function collectHeap(): Promise<Buffer> {
-  const profiler: PyroscopeProfiler = getProfiler()
+  const profiler: PyroscopeProfiler = getProfiler();
 
   const heapProfilerArgs: HeapProfilerStartArgs =
-    profiler.heapProfiler.startArgs
+    profiler.heapProfiler.startArgs;
   const heapProfiler: Profiler<HeapProfilerStartArgs> =
-    profiler.heapProfiler.profiler
+    profiler.heapProfiler.profiler;
 
-  return collectProfileAfterMs(heapProfiler, heapProfilerArgs, 0)
+  return collectProfileAfterMs(heapProfiler, heapProfilerArgs, 0);
 }
 
 function collectWall(ms: number): Promise<Buffer> {
-  const profiler: PyroscopeProfiler = getProfiler()
+  const profiler: PyroscopeProfiler = getProfiler();
 
   const wallProfilerArgs: WallProfilerStartArgs =
-    profiler.wallProfiler.startArgs
+    profiler.wallProfiler.startArgs;
   const wallProfiler: Profiler<WallProfilerStartArgs> =
-    profiler.wallProfiler.profiler
+    profiler.wallProfiler.profiler;
 
-  return collectProfileAfterMs(wallProfiler, wallProfilerArgs, ms)
+  return collectProfileAfterMs(wallProfiler, wallProfilerArgs, ms);
 }
 
 function profileExpressHandler(
@@ -71,25 +71,25 @@ function profileExpressHandler(
     res: Response
     // next: NextFunction
   ): Promise<void> => {
-    log(`Fetching ${profileKind} Profile`)
+    log(`Fetching ${profileKind} Profile`);
     try {
-      const profileBuffer = await useCaseHandler(req)
-      res.status(200).send(profileBuffer)
+      const profileBuffer = await useCaseHandler(req);
+      res.status(200).send(profileBuffer);
     } catch (error: unknown) {
-      log(`Error collecting ${profileKind}`, error)
-      res.sendStatus(500)
+      log(`Error collecting ${profileKind}`, error);
+      res.sendStatus(500);
     }
-  }
+  };
 }
 
 const heapHandler: RequestHandler = profileExpressHandler('Heap', () =>
   collectHeap()
-)
+);
 
 const wallHandler: RequestHandler = profileExpressHandler(
   'Wall',
   (req: Request) => collectWall(1000 * Number(req.query.seconds))
-)
+);
 
 export default function expressMiddleware(): (
   req: Request,
@@ -99,12 +99,12 @@ export default function expressMiddleware(): (
   return (req: Request, res: Response, next: NextFunction) => {
     if (req.method === 'GET') {
       if (req.path === '/debug/pprof/heap') {
-        return heapHandler(req, res, next)
+        return heapHandler(req, res, next);
       }
       if (req.path === '/debug/pprof/profile') {
-        return wallHandler(req, res, next)
+        return wallHandler(req, res, next);
       }
     }
-    next()
-  }
+    next();
+  };
 }

src/index.ts

@@ -1,94 +1,94 @@
-import 'regenerator-runtime/runtime'
+import 'regenerator-runtime/runtime';
 
-import expressMiddleware from './express/middleware'
-import { PyroscopeProfiler } from './profilers/pyroscope-profiler'
+import expressMiddleware from './express/middleware';
+import { PyroscopeProfiler } from './profilers/pyroscope-profiler';
 import {
   PyroscopeConfig,
   PyroscopeHeapConfig,
   PyroscopeWallConfig,
-} from './pyroscope-config'
-import { checkPyroscopeConfig } from './utils/check-pyroscope-config'
-import { getProfiler, setProfiler } from './utils/pyroscope-profiler'
-import { processConfig } from './utils/process-config'
-import { getEnv } from './utils/get-env'
-import { setLogger as datadogSetLogger } from '@datadog/pprof'
-import { setLogger as ourSetLogger, Logger } from './logger'
-import { SourceMapper } from './sourcemapper'
+} from './pyroscope-config';
+import { checkPyroscopeConfig } from './utils/check-pyroscope-config';
+import { getProfiler, setProfiler } from './utils/pyroscope-profiler';
+import { processConfig } from './utils/process-config';
+import { getEnv } from './utils/get-env';
+import { setLogger as datadogSetLogger } from '@datadog/pprof';
+import { setLogger as ourSetLogger, Logger } from './logger';
+import { SourceMapper } from './sourcemapper';
 
 export function init(config: PyroscopeConfig = {}): void {
-  checkPyroscopeConfig(config)
+  checkPyroscopeConfig(config);
 
-  const processedConfig: PyroscopeConfig = processConfig(config, getEnv())
+  const processedConfig: PyroscopeConfig = processConfig(config, getEnv());
 
-  setProfiler(new PyroscopeProfiler(processedConfig))
+  setProfiler(new PyroscopeProfiler(processedConfig));
 }
 
 // deprecated: please use getLabels
 function getWallLabels(): Record<string, number | string> {
-  return getLabels()
+  return getLabels();
 }
 
 // deprecated: please use setLabels
 function setWallLabels(labels: Record<string, number | string>): void {
-  return setLabels(labels)
+  return setLabels(labels);
 }
 
 function getLabels(): Record<string, number | string> {
-  return getProfiler().wallProfiler.profiler.getLabels()
+  return getProfiler().wallProfiler.profiler.getLabels();
 }
 
 function setLabels(labels: Record<string, number | string>): void {
-  getProfiler().wallProfiler.profiler.setLabels(labels)
+  getProfiler().wallProfiler.profiler.setLabels(labels);
 }
 
 export function wrapWithLabels(
   lbls: Record<string, string | number>,
   fn: () => void,
   ...args: unknown[]
 ): void {
-  getProfiler().wallProfiler.profiler.wrapWithLabels(lbls, fn, ...args)
+  getProfiler().wallProfiler.profiler.wrapWithLabels(lbls, fn, ...args);
 }
 
 function startWallProfiling(): void {
-  getProfiler().wallProfiler.start()
+  getProfiler().wallProfiler.start();
 }
 
 // here for backwards compatibility
 function startCpuProfiling(): void {
-  getProfiler().wallProfiler.start()
+  getProfiler().wallProfiler.start();
 }
 
 async function stopWallProfiling(): Promise<void> {
-  await getProfiler().wallProfiler.stop()
+  await getProfiler().wallProfiler.stop();
 }
 
 // here for backwards compatibility
 async function stopCpuProfiling(): Promise<void> {
-  await getProfiler().wallProfiler.stop()
+  await getProfiler().wallProfiler.stop();
 }
 
 function startHeapProfiling(): void {
-  getProfiler().heapProfiler.start()
+  getProfiler().heapProfiler.start();
 }
 
 async function stopHeapProfiling(): Promise<void> {
-  await getProfiler().heapProfiler.stop()
+  await getProfiler().heapProfiler.stop();
 }
 
 export function start(): void {
-  startWallProfiling()
-  startHeapProfiling()
+  startWallProfiling();
+  startHeapProfiling();
 }
 
 export async function stop(): Promise<void> {
-  await Promise.all([stopWallProfiling(), stopHeapProfiling()])
+  await Promise.all([stopWallProfiling(), stopHeapProfiling()]);
 }
 
-export { PyroscopeConfig, PyroscopeHeapConfig, PyroscopeWallConfig }
+export { PyroscopeConfig, PyroscopeHeapConfig, PyroscopeWallConfig };
 
 function setLogger(logger: Logger): void {
-  datadogSetLogger(logger)
-  ourSetLogger(logger)
+  datadogSetLogger(logger);
+  ourSetLogger(logger);
 }
 
 export default {
@@ -109,4 +109,4 @@ export default {
   stopWallProfiling,
   stopCpuProfiling,
   setLogger,
-}
+};