feat(core): Extract objects as structured logs in consoleLoggingIntegration (#21385)

Aligns the console integration so object-first logs are structured,
matching the consola integration behavior. If the first argument is an
object, the keys are added as log attributes.

Reference PR (consola):
#19534



The universal principle is this:
```
IF first_argument is plain_object:
    attributes ← first_argument keys/values
    message ← second_argument (if string) OR empty
    remaining_args → sentry.message.parameter.{0, 1, 2...}
ELSE:
    message ← formatted(all_args)
    args[1:] → sentry.message.parameter.{0, 1, 2...}
```

### Example Snippet

```js
console.warn({ component: 'PaymentService', retryCount: 3 }, 500, 'TIMEOUT');
console.info(
    { userId: 42, action: 'purchase' },
    'Console [OBJ-FIRST+PARAMS]: Checkout complete',
    testOrder.orderId,
    testOrder.total,
);
```

#### Before

<img width="1434" height="662" alt="image"
src="https://github.com/user-attachments/assets/19f310dd-d417-48fd-acb3-7695e28417b7"
/>


#### After

<img width="1425" height="665" alt="image"
src="https://github.com/user-attachments/assets/6f722ce3-e698-46fa-ba22-5f1f42304f65"
/>

Author: s1gr1d

CHANGELOG.md

@@ -4,6 +4,20 @@
 
 - "You miss 100 percent of the chances you don't take. — Wayne Gretzky" — Michael Scott
 
+- **feat(core): Extract objects as structured logs in `consoleLoggingIntegration`**
+
+  The `consoleLoggingIntegration` now extracts structured log attributes when the first argument is a plain object.
+
+  ```js
+  // Object keys become log attributes
+  console.log({ userId: 123, action: 'login' }, 'User logged in');
+  // → attributes: { userId: 123, action: "login" }
+
+  // Non-object first args use template + parameters (unchanged)
+  console.log('Hello', 'world', 123);
+  // → sentry.message.template: "Hello {} {}"
+  ```
+
 ## 10.57.0
 
 ### Important Changes

packages/core/src/logs/console-integration.ts

@@ -6,6 +6,8 @@ import { SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN } from '../semanticAttributes';
 import type { ConsoleLevel } from '../types/instrument';
 import type { IntegrationFn } from '../types/integration';
 import { CONSOLE_LEVELS, debug } from '../utils/debug-logger';
+import { isPlainObject } from '../utils/is';
+import { normalize } from '../utils/normalize';
 import { _INTERNAL_captureLog } from './internal';
 import { createConsoleTemplateAttributes, formatConsoleArgs, hasConsoleSubstitutions } from './utils';
 
@@ -52,12 +54,32 @@ const _consoleLoggingIntegration = ((options: Partial<CaptureConsoleOptions> = {
 
         const isLevelLog = level === 'log';
 
-        const shouldGenerateTemplate =
-          args.length > 1 && typeof args[0] === 'string' && !hasConsoleSubstitutions(args[0]);
-        const attributes = {
-          ...DEFAULT_ATTRIBUTES,
-          ...(shouldGenerateTemplate ? createConsoleTemplateAttributes(firstArg, followingArgs) : {}),
-        };
+        const attributes: Record<string, unknown> = { ...DEFAULT_ATTRIBUTES };
+
+        if (isPlainObject(firstArg)) {
+          // Object-first: extract object keys as attributes, remaining args as parameters
+          Object.assign(attributes, normalize(firstArg, normalizeDepth, normalizeMaxBreadth));
+
+          const remainingArgsStartIndex = typeof args[1] === 'string' ? 2 : 1;
+          const remainingArgs = args.slice(remainingArgsStartIndex);
+
+          remainingArgs.forEach((arg, index) => {
+            attributes[`sentry.message.parameter.${index}`] = normalize(arg, normalizeDepth, normalizeMaxBreadth);
+          });
+        } else {
+          // Fallback: template + parameters when first arg is a string without substitutions
+          const shouldGenerateTemplate =
+            followingArgs.length > 0 && typeof firstArg === 'string' && !hasConsoleSubstitutions(firstArg);
+
+          if (shouldGenerateTemplate) {
+            const templateAttrs = createConsoleTemplateAttributes(firstArg, followingArgs);
+            for (const [key, value] of Object.entries(templateAttrs)) {
+              attributes[key] = key.startsWith('sentry.message.parameter.')
+                ? normalize(value, normalizeDepth, normalizeMaxBreadth)
+                : value;
+            }
+          }
+        }
 
         _INTERNAL_captureLog({
           level: isLevelLog ? 'info' : level,