From a3c43dda946080239834a241ac34e8f2bfb020d4 Mon Sep 17 00:00:00 2001 From: Francesco Novy Date: Thu, 10 Jul 2025 10:35:28 +0200 Subject: [PATCH 1/4] feat(logs): Ensure client & scope can be passed to log functions --- packages/browser/src/log.ts | 61 +++-- packages/browser/test/log.test.ts | 158 ++++++++----- packages/node-core/src/logs/capture.ts | 41 +++- packages/node-core/test/logs/exports.test.ts | 230 ++++++++++++++----- 4 files changed, 347 insertions(+), 143 deletions(-) diff --git a/packages/browser/src/log.ts b/packages/browser/src/log.ts index ef2614b81f55..ed355e968c08 100644 --- a/packages/browser/src/log.ts +++ b/packages/browser/src/log.ts @@ -1,4 +1,4 @@ -import type { Log, LogSeverityLevel, ParameterizedString } from '@sentry/core'; +import type { Client, Log, LogSeverityLevel, ParameterizedString, Scope } from '@sentry/core'; import { _INTERNAL_captureLog } from '@sentry/core'; /** @@ -13,9 +13,10 @@ function captureLog( level: LogSeverityLevel, message: ParameterizedString, attributes?: Log['attributes'], - severityNumber?: Log['severityNumber'], + client?: Client, + scope?: Scope, ): void { - _INTERNAL_captureLog({ level, message, attributes, severityNumber }); + _INTERNAL_captureLog({ level, message, attributes }, client, scope); } /** @@ -43,8 +44,13 @@ function captureLog( * }); * ``` */ -export function trace(message: ParameterizedString, attributes?: Log['attributes']): void { - captureLog('trace', message, attributes); +export function trace( + message: ParameterizedString, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +): void { + captureLog('trace', message, attributes, client, scope); } /** @@ -73,8 +79,13 @@ export function trace(message: ParameterizedString, attributes?: Log['attributes * }); * ``` */ -export function debug(message: ParameterizedString, attributes?: Log['attributes']): void { - captureLog('debug', message, attributes); +export function debug( + message: ParameterizedString, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +): void { + captureLog('debug', message, attributes, client, scope); } /** @@ -103,8 +114,13 @@ export function debug(message: ParameterizedString, attributes?: Log['attributes * }); * ``` */ -export function info(message: ParameterizedString, attributes?: Log['attributes']): void { - captureLog('info', message, attributes); +export function info( + message: ParameterizedString, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +): void { + captureLog('info', message, attributes, client, scope); } /** @@ -134,8 +150,13 @@ export function info(message: ParameterizedString, attributes?: Log['attributes' * }); * ``` */ -export function warn(message: ParameterizedString, attributes?: Log['attributes']): void { - captureLog('warn', message, attributes); +export function warn( + message: ParameterizedString, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +): void { + captureLog('warn', message, attributes, client, scope); } /** @@ -166,8 +187,13 @@ export function warn(message: ParameterizedString, attributes?: Log['attributes' * }); * ``` */ -export function error(message: ParameterizedString, attributes?: Log['attributes']): void { - captureLog('error', message, attributes); +export function error( + message: ParameterizedString, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +): void { + captureLog('error', message, attributes, client, scope); } /** @@ -198,8 +224,13 @@ export function error(message: ParameterizedString, attributes?: Log['attributes * }); * ``` */ -export function fatal(message: ParameterizedString, attributes?: Log['attributes']): void { - captureLog('fatal', message, attributes); +export function fatal( + message: ParameterizedString, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +): void { + captureLog('fatal', message, attributes, client, scope); } export { fmt } from '@sentry/core'; diff --git a/packages/browser/test/log.test.ts b/packages/browser/test/log.test.ts index 68c87069966c..59cc1d36f72e 100644 --- a/packages/browser/test/log.test.ts +++ b/packages/browser/test/log.test.ts @@ -5,7 +5,8 @@ import * as sentryCore from '@sentry/core'; import { getCurrentScope, getGlobalScope, getIsolationScope } from '@sentry/core'; import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; -import { init, logger } from '../src'; +import { BrowserClient, init, logger } from '../src'; +import { getDefaultBrowserClientOptions } from './helper/browser-client-options'; import { makeSimpleTransport } from './mocks/simpletransport'; const dsn = 'https://53039209a22b4ec1bcc296a3c9fdecd6@sentry.io/4291'; @@ -66,87 +67,138 @@ describe('Logger', () => { it('should call _INTERNAL_captureLog with trace level', () => { logger.trace('Test trace message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'trace', - message: 'Test trace message', - attributes: { key: 'value' }, - severityNumber: undefined, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'trace', + message: 'Test trace message', + attributes: { key: 'value' }, + severityNumber: undefined, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with debug level', () => { logger.debug('Test debug message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'debug', - message: 'Test debug message', - attributes: { key: 'value' }, - severityNumber: undefined, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'debug', + message: 'Test debug message', + attributes: { key: 'value' }, + severityNumber: undefined, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with info level', () => { logger.info('Test info message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'info', - message: 'Test info message', - attributes: { key: 'value' }, - severityNumber: undefined, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'info', + message: 'Test info message', + attributes: { key: 'value' }, + severityNumber: undefined, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with warn level', () => { logger.warn('Test warn message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'warn', - message: 'Test warn message', - attributes: { key: 'value' }, - severityNumber: undefined, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'warn', + message: 'Test warn message', + attributes: { key: 'value' }, + severityNumber: undefined, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with error level', () => { logger.error('Test error message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'error', - message: 'Test error message', - attributes: { key: 'value' }, - severityNumber: undefined, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'error', + message: 'Test error message', + attributes: { key: 'value' }, + severityNumber: undefined, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with fatal level', () => { logger.fatal('Test fatal message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'fatal', - message: 'Test fatal message', - attributes: { key: 'value' }, - severityNumber: undefined, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'fatal', + message: 'Test fatal message', + attributes: { key: 'value' }, + severityNumber: undefined, + }, + undefined, + undefined, + ); }); }); it('should handle parameterized strings with parameters', () => { logger.info(logger.fmt`Hello ${'John'}, your balance is ${100}`, { userId: 123 }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'info', - message: expect.objectContaining({ - __sentry_template_string__: 'Hello %s, your balance is %s', - __sentry_template_values__: ['John', 100], - }), - attributes: { - userId: 123, + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'info', + message: expect.objectContaining({ + __sentry_template_string__: 'Hello %s, your balance is %s', + __sentry_template_values__: ['John', 100], + }), + attributes: { + userId: 123, + }, }, - }); + undefined, + undefined, + ); }); it('should handle parameterized strings without additional attributes', () => { logger.debug(logger.fmt`User ${'Alice'} logged in from ${'mobile'}`); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'debug', - message: expect.objectContaining({ - __sentry_template_string__: 'User %s logged in from %s', - __sentry_template_values__: ['Alice', 'mobile'], - }), - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'debug', + message: expect.objectContaining({ + __sentry_template_string__: 'User %s logged in from %s', + __sentry_template_values__: ['Alice', 'mobile'], + }), + }, + undefined, + undefined, + ); }); + + it.each(['trace', 'debug', 'info', 'warn', 'error', 'fatal'] as const)( + 'should allow to pass a client and scope for %s level', + level => { + const client = new BrowserClient(getDefaultBrowserClientOptions()); + const scope = new sentryCore.Scope(); + + logger[level]('Test message', { key: 'value' }, client, scope); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level, + message: 'Test message', + attributes: { key: 'value' }, + }, + client, + scope, + ); + }, + ); }); diff --git a/packages/node-core/src/logs/capture.ts b/packages/node-core/src/logs/capture.ts index 17f94399f9bf..1c78a41361ef 100644 --- a/packages/node-core/src/logs/capture.ts +++ b/packages/node-core/src/logs/capture.ts @@ -1,10 +1,22 @@ import { format } from 'node:util'; -import type { Log, LogSeverityLevel, ParameterizedString } from '@sentry/core'; +import type { Client, Log, LogSeverityLevel, ParameterizedString, Scope } from '@sentry/core'; import { _INTERNAL_captureLog } from '@sentry/core'; -export type CaptureLogArgs = - | [message: ParameterizedString, attributes?: Log['attributes']] - | [messageTemplate: string, messageParams: Array, attributes?: Log['attributes']]; +type CaptureLogsArgsParametrized = [ + message: ParameterizedString, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +]; +type CaptureLogsArgsTemplate = [ + messageTemplate: string, + messageParams: Array, + attributes?: Log['attributes'], + client?: Client, + scope?: Scope, +]; + +export type CaptureLogArgs = CaptureLogsArgsParametrized | CaptureLogsArgsTemplate; /** * Capture a log with the given level. @@ -14,16 +26,21 @@ export type CaptureLogArgs = * @param attributes - Arbitrary structured data that stores information about the log - e.g., userId: 100. */ export function captureLog(level: LogSeverityLevel, ...args: CaptureLogArgs): void { - const [messageOrMessageTemplate, paramsOrAttributes, maybeAttributes] = args; - if (Array.isArray(paramsOrAttributes)) { - const attributes = { ...maybeAttributes }; - attributes['sentry.message.template'] = messageOrMessageTemplate; - paramsOrAttributes.forEach((param, index) => { + if (!isParametrizedArgs(args)) { + const [messageTemplate, messageParams, messageAttributes, client, scope] = args; + const attributes = { ...messageAttributes }; + attributes['sentry.message.template'] = messageTemplate; + messageParams.forEach((param, index) => { attributes[`sentry.message.parameter.${index}`] = param; }); - const message = format(messageOrMessageTemplate, ...paramsOrAttributes); - _INTERNAL_captureLog({ level, message, attributes }); + const message = format(messageTemplate, ...messageParams); + _INTERNAL_captureLog({ level, message, attributes }, client, scope); } else { - _INTERNAL_captureLog({ level, message: messageOrMessageTemplate, attributes: paramsOrAttributes }); + const [message, attributes, client, scope] = args; + _INTERNAL_captureLog({ level, message, attributes }, client, scope); } } + +function isParametrizedArgs(args: CaptureLogArgs): args is CaptureLogsArgsParametrized { + return !Array.isArray(args[1]); +} diff --git a/packages/node-core/test/logs/exports.test.ts b/packages/node-core/test/logs/exports.test.ts index 9e1cc4900e29..97e57b7b42d0 100644 --- a/packages/node-core/test/logs/exports.test.ts +++ b/packages/node-core/test/logs/exports.test.ts @@ -1,6 +1,8 @@ import * as sentryCore from '@sentry/core'; import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'; +import { NodeClient } from '../../src'; import * as nodeLogger from '../../src/logs/exports'; +import { getDefaultNodeClientOptions } from '../helpers/getDefaultNodeClientOptions'; // Mock the core functions vi.mock('@sentry/core', async () => { @@ -36,110 +38,212 @@ describe('Node Logger', () => { it('should call _INTERNAL_captureLog with trace level', () => { nodeLogger.trace('Test trace message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'trace', - message: 'Test trace message', - attributes: { key: 'value' }, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'trace', + message: 'Test trace message', + attributes: { key: 'value' }, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with debug level', () => { nodeLogger.debug('Test debug message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'debug', - message: 'Test debug message', - attributes: { key: 'value' }, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'debug', + message: 'Test debug message', + attributes: { key: 'value' }, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with info level', () => { nodeLogger.info('Test info message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'info', - message: 'Test info message', - attributes: { key: 'value' }, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'info', + message: 'Test info message', + attributes: { key: 'value' }, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with warn level', () => { nodeLogger.warn('Test warn message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'warn', - message: 'Test warn message', - attributes: { key: 'value' }, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'warn', + message: 'Test warn message', + attributes: { key: 'value' }, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with error level', () => { nodeLogger.error('Test error message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'error', - message: 'Test error message', - attributes: { key: 'value' }, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'error', + message: 'Test error message', + attributes: { key: 'value' }, + }, + undefined, + undefined, + ); }); it('should call _INTERNAL_captureLog with fatal level', () => { nodeLogger.fatal('Test fatal message', { key: 'value' }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'fatal', - message: 'Test fatal message', - attributes: { key: 'value' }, - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'fatal', + message: 'Test fatal message', + attributes: { key: 'value' }, + }, + undefined, + undefined, + ); }); }); describe('Template string logging', () => { it('should handle template strings with parameters', () => { nodeLogger.info('Hello %s, your balance is %d', ['John', 100], { userId: 123 }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'info', - message: 'Hello John, your balance is 100', - attributes: { - userId: 123, - 'sentry.message.template': 'Hello %s, your balance is %d', - 'sentry.message.parameter.0': 'John', - 'sentry.message.parameter.1': 100, + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'info', + message: 'Hello John, your balance is 100', + attributes: { + userId: 123, + 'sentry.message.template': 'Hello %s, your balance is %d', + 'sentry.message.parameter.0': 'John', + 'sentry.message.parameter.1': 100, + }, }, - }); + undefined, + undefined, + ); }); it('should handle template strings without additional attributes', () => { nodeLogger.debug('User %s logged in from %s', ['Alice', 'mobile']); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'debug', - message: 'User Alice logged in from mobile', - attributes: { - 'sentry.message.template': 'User %s logged in from %s', - 'sentry.message.parameter.0': 'Alice', - 'sentry.message.parameter.1': 'mobile', + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'debug', + message: 'User Alice logged in from mobile', + attributes: { + 'sentry.message.template': 'User %s logged in from %s', + 'sentry.message.parameter.0': 'Alice', + 'sentry.message.parameter.1': 'mobile', + }, }, - }); + undefined, + undefined, + ); }); it('should handle parameterized strings with parameters', () => { nodeLogger.info(nodeLogger.fmt`Hello ${'John'}, your balance is ${100}`, { userId: 123 }); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'info', - message: expect.objectContaining({ - __sentry_template_string__: 'Hello %s, your balance is %s', - __sentry_template_values__: ['John', 100], - }), - attributes: { - userId: 123, + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'info', + message: expect.objectContaining({ + __sentry_template_string__: 'Hello %s, your balance is %s', + __sentry_template_values__: ['John', 100], + }), + attributes: { + userId: 123, + }, }, - }); + undefined, + undefined, + ); }); it('should handle parameterized strings without additional attributes', () => { nodeLogger.debug(nodeLogger.fmt`User ${'Alice'} logged in from ${'mobile'}`); - expect(mockCaptureLog).toHaveBeenCalledWith({ - level: 'debug', - message: expect.objectContaining({ - __sentry_template_string__: 'User %s logged in from %s', - __sentry_template_values__: ['Alice', 'mobile'], - }), - }); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level: 'debug', + message: expect.objectContaining({ + __sentry_template_string__: 'User %s logged in from %s', + __sentry_template_values__: ['Alice', 'mobile'], + }), + }, + undefined, + undefined, + ); }); }); + + describe.each(['trace', 'debug', 'info', 'warn', 'error', 'fatal'] as const)( + 'passing client and scope for %s level', + level => { + it('should allow to pass a client and scope with plain message', () => { + const client = new NodeClient(getDefaultNodeClientOptions()); + const scope = new sentryCore.Scope(); + + nodeLogger[level]('Test message', { key: 'value' }, client, scope); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level, + message: 'Test message', + attributes: { key: 'value' }, + }, + client, + scope, + ); + }); + + it('should allow to pass a client and scope with parametrized string', () => { + const client = new NodeClient(getDefaultNodeClientOptions()); + const scope = new sentryCore.Scope(); + + nodeLogger[level](nodeLogger.fmt`Hello ${'John'}, your balance is ${100}`, { userId: 123 }, client, scope); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level, + message: expect.objectContaining({ + __sentry_template_string__: 'Hello %s, your balance is %s', + __sentry_template_values__: ['John', 100], + }), + attributes: { + userId: 123, + }, + }, + client, + scope, + ); + }); + + it('should allow to pass a client and scope with template string', () => { + const client = new NodeClient(getDefaultNodeClientOptions()); + const scope = new sentryCore.Scope(); + + nodeLogger[level]('User %s logged in from %s', ['Alice', 'mobile'], {}, client, scope); + expect(mockCaptureLog).toHaveBeenCalledWith( + { + level, + message: 'User Alice logged in from mobile', + attributes: { + 'sentry.message.template': 'User %s logged in from %s', + 'sentry.message.parameter.0': 'Alice', + 'sentry.message.parameter.1': 'mobile', + }, + }, + client, + scope, + ); + }); + }, + ); }); From fec8d48552384db09e1ed77fe3989eb2288885e1 Mon Sep 17 00:00:00 2001 From: Francesco Novy Date: Thu, 10 Jul 2025 10:39:08 +0200 Subject: [PATCH 2/4] add size limit --- .size-limit.js | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/.size-limit.js b/.size-limit.js index 685b40b00fbe..39d2b883ba9a 100644 --- a/.size-limit.js +++ b/.size-limit.js @@ -84,6 +84,13 @@ module.exports = [ gzip: true, limit: '95 KB', }, + { + name: '@sentry/browser (incl. Logs)', + path: 'packages/browser/build/npm/esm/index.js', + import: createImport('init', 'logger'), + gzip: true, + limit: '40 KB', + }, { name: '@sentry/browser (incl. Feedback)', path: 'packages/browser/build/npm/esm/index.js', From fec890f932d21eb42ffc4330fe3c4630e51fccd8 Mon Sep 17 00:00:00 2001 From: Francesco Novy Date: Thu, 10 Jul 2025 10:43:10 +0200 Subject: [PATCH 3/4] remove unused --- packages/browser/src/log.ts | 1 - packages/browser/test/log.test.ts | 6 ------ 2 files changed, 7 deletions(-) diff --git a/packages/browser/src/log.ts b/packages/browser/src/log.ts index ed355e968c08..de7d15e4b3ad 100644 --- a/packages/browser/src/log.ts +++ b/packages/browser/src/log.ts @@ -7,7 +7,6 @@ import { _INTERNAL_captureLog } from '@sentry/core'; * @param level - The level of the log. * @param message - The message to log. * @param attributes - Arbitrary structured data that stores information about the log - e.g., userId: 100. - * @param severityNumber - The severity number of the log. */ function captureLog( level: LogSeverityLevel, diff --git a/packages/browser/test/log.test.ts b/packages/browser/test/log.test.ts index 59cc1d36f72e..02491462de46 100644 --- a/packages/browser/test/log.test.ts +++ b/packages/browser/test/log.test.ts @@ -72,7 +72,6 @@ describe('Logger', () => { level: 'trace', message: 'Test trace message', attributes: { key: 'value' }, - severityNumber: undefined, }, undefined, undefined, @@ -86,7 +85,6 @@ describe('Logger', () => { level: 'debug', message: 'Test debug message', attributes: { key: 'value' }, - severityNumber: undefined, }, undefined, undefined, @@ -100,7 +98,6 @@ describe('Logger', () => { level: 'info', message: 'Test info message', attributes: { key: 'value' }, - severityNumber: undefined, }, undefined, undefined, @@ -114,7 +111,6 @@ describe('Logger', () => { level: 'warn', message: 'Test warn message', attributes: { key: 'value' }, - severityNumber: undefined, }, undefined, undefined, @@ -128,7 +124,6 @@ describe('Logger', () => { level: 'error', message: 'Test error message', attributes: { key: 'value' }, - severityNumber: undefined, }, undefined, undefined, @@ -142,7 +137,6 @@ describe('Logger', () => { level: 'fatal', message: 'Test fatal message', attributes: { key: 'value' }, - severityNumber: undefined, }, undefined, undefined, From bff9360e268cbdd9b2d2fbc9d8afde92472adafc Mon Sep 17 00:00:00 2001 From: Francesco Novy Date: Thu, 10 Jul 2025 10:51:58 +0200 Subject: [PATCH 4/4] small ref --- .size-limit.js | 2 +- packages/node-core/src/logs/capture.ts | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.size-limit.js b/.size-limit.js index 39d2b883ba9a..77e60133b748 100644 --- a/.size-limit.js +++ b/.size-limit.js @@ -89,7 +89,7 @@ module.exports = [ path: 'packages/browser/build/npm/esm/index.js', import: createImport('init', 'logger'), gzip: true, - limit: '40 KB', + limit: '26 KB', }, { name: '@sentry/browser (incl. Feedback)', diff --git a/packages/node-core/src/logs/capture.ts b/packages/node-core/src/logs/capture.ts index 1c78a41361ef..f3a67480d51b 100644 --- a/packages/node-core/src/logs/capture.ts +++ b/packages/node-core/src/logs/capture.ts @@ -26,7 +26,7 @@ export type CaptureLogArgs = CaptureLogsArgsParametrized | CaptureLogsArgsTempla * @param attributes - Arbitrary structured data that stores information about the log - e.g., userId: 100. */ export function captureLog(level: LogSeverityLevel, ...args: CaptureLogArgs): void { - if (!isParametrizedArgs(args)) { + if (isTemplateArgs(args)) { const [messageTemplate, messageParams, messageAttributes, client, scope] = args; const attributes = { ...messageAttributes }; attributes['sentry.message.template'] = messageTemplate; @@ -41,6 +41,6 @@ export function captureLog(level: LogSeverityLevel, ...args: CaptureLogArgs): vo } } -function isParametrizedArgs(args: CaptureLogArgs): args is CaptureLogsArgsParametrized { - return !Array.isArray(args[1]); +function isTemplateArgs(args: CaptureLogArgs): args is CaptureLogsArgsTemplate { + return Array.isArray(args[1]); }