@ogcio/o11y-sdk-node 0.1.0-beta.9 → 0.3.0

package/test/internals/shared-metrics.test.ts

@@ -0,0 +1,34 @@
+vi.mock("../../lib/metrics", () => {
+  return {
+    getMetric: vi.fn(),
+  };
+});
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { _getPIICounterRedactionMetric } from "../../lib/internals/shared-metrics.js";
+import { getMetric } from "../../lib/metrics"; // Get the mocked function
+
+describe("shared metrics", () => {
+  const mockMetric = { add: vi.fn() };
+
+  beforeEach(() => {
+    vi.resetModules(); // Clear module-level cache
+    vi.restoreAllMocks();
+    (getMetric as vi.Mock).mockClear(); // clear call history
+    (getMetric as vi.Mock).mockReturnValue(mockMetric);
+  });
+
+  it("calls getMetric with correct arguments and caches result", () => {
+    const metric1 = _getPIICounterRedactionMetric();
+    const metric2 = _getPIICounterRedactionMetric();
+
+    expect(getMetric).toHaveBeenCalledOnce();
+    expect(getMetric).toHaveBeenCalledWith("counter", {
+      meterName: "o11y",
+      metricName: "o11y_pii_redaction",
+    });
+
+    expect(metric1).toBe(mockMetric);
+    expect(metric2).toBe(mockMetric); // should be cached
+  });
+});

package/test/node-config.test.ts

@@ -1,25 +1,20 @@
-import { test, describe, assert, expect } from "vitest";
+import { NodeSDK, metrics } from "@opentelemetry/sdk-node";
+import { afterAll, assert, describe, expect, test } from "vitest";
 import buildNodeInstrumentation from "../lib/instrumentation.node.js";
-import { NodeSDK, logs, metrics, tracing } from "@opentelemetry/sdk-node";
-import { OTLPTraceExporter as GRPC_OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
-import { OTLPMetricExporter as GRPC_OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
-import { OTLPLogExporter as GRPC_OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
-
-import { OTLPTraceExporter as HTTP_OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { OTLPMetricExporter as HTTP_OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { OTLPLogExporter as HTTP_OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
-import { NodeSDKConfig } from "../lib/index.js";
-import buildHttpExporters from "../lib/exporter/http.js";
-import {
-  BatchSpanProcessor,
-  ConsoleSpanExporter,
-  SimpleSpanProcessor,
-} from "@opentelemetry/sdk-trace-base";
+
 import {
   BatchLogRecordProcessor,
   SimpleLogRecordProcessor,
 } from "@opentelemetry/sdk-logs";
+import {
+  BatchSpanProcessor,
+  SimpleSpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import buildHttpExporters from "../lib/exporter/http.js";
+import { NodeSDKConfig } from "../lib/index.js";
+import { EnrichLogProcessor } from "../lib/processor/enrich-logger-processor.js";
 import { EnrichSpanProcessor } from "../lib/processor/enrich-span-processor.js";
+import { PIIExporterDecorator } from "../lib/exporter/pii-exporter-decorator.js";
 
 describe("verify config settings", () => {
   const commonConfig = {
@@ -27,7 +22,7 @@ describe("verify config settings", () => {
     serviceName: "test",
   };
 
-  test("grpc config", () => {
+  test("grpc config", async () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "grpc",
@@ -35,7 +30,7 @@ describe("verify config settings", () => {
       diagLogLevel: "NONE",
     };
 
-    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
 
     assert.ok(sdk);
 
@@ -44,14 +39,13 @@ describe("verify config settings", () => {
 
     const logs = _configuration.logRecordProcessors;
 
-    assert.equal(logs.length, 2);
-    assert.ok(logs[1] instanceof BatchLogRecordProcessor);
+    assert.equal(logs.length, 1);
+    assert.ok(logs[logs.length - 1] instanceof BatchLogRecordProcessor);
 
     const spans = _configuration.spanProcessors;
 
-    assert.equal(spans.length, 2);
+    assert.equal(spans.length, 1);
     assert.ok(spans[0] instanceof BatchSpanProcessor);
-    assert.ok(spans[1] instanceof EnrichSpanProcessor);
 
     assert.ok(
       _configuration.metricReader instanceof
@@ -59,14 +53,17 @@ describe("verify config settings", () => {
     );
   });
 
-  test("http config", () => {
+  test("http config", async () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "http",
       diagLogLevel: "NONE",
+      spanAttributes: {
+        name: "custom-value",
+      },
     };
 
-    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
     assert.ok(sdk);
 
     const _configuration = sdk["_configuration"];
@@ -75,6 +72,7 @@ describe("verify config settings", () => {
     const logs = _configuration.logRecordProcessors;
 
     assert.equal(logs.length, 2);
+    assert.ok(logs[0] instanceof EnrichLogProcessor);
     assert.ok(logs[1] instanceof BatchLogRecordProcessor);
 
     const spans = _configuration.spanProcessors;
@@ -89,14 +87,17 @@ describe("verify config settings", () => {
     );
   });
 
-  test("console - console config", () => {
+  test("console - console config", async () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "console",
       diagLogLevel: "NONE",
+      spanAttributes: {
+        name: "custom-name",
+      },
     };
 
-    const sdk: NodeSDK = buildNodeInstrumentation(config)!;
+    const sdk: NodeSDK = await buildNodeInstrumentation(config)!;
     assert.ok(sdk);
 
     const _configuration = sdk["_configuration"];
@@ -106,6 +107,7 @@ describe("verify config settings", () => {
 
     // verify simple log processor for instant console logging
     assert.equal(logs.length, 2);
+    assert.ok(logs[0] instanceof EnrichLogProcessor);
     assert.ok(logs[1] instanceof SimpleLogRecordProcessor);
 
     const spans = _configuration.spanProcessors;
@@ -121,23 +123,54 @@ describe("verify config settings", () => {
     );
   });
 
-  test("single log sending config", () => {
+  test("single log sending config", async () => {
+    const config: NodeSDKConfig = {
+      ...commonConfig,
+      protocol: "grpc",
+      diagLogLevel: "NONE",
+      collectorMode: "single",
+    };
+
+    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
+
+    assert.ok(sdk);
+
+    const _configuration = sdk["_configuration"];
+
+    const logRecordProcessors = _configuration.logRecordProcessors;
+    assert.equal(logRecordProcessors.length, 1);
+    assert.ok(
+      logRecordProcessors[logRecordProcessors.length - 1] instanceof
+        SimpleLogRecordProcessor,
+    );
+  });
+
+  test("pii exporter decorator injected by default", async () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "grpc",
       diagLogLevel: "NONE",
       collectorMode: "single",
+      detection: {},
     };
 
-    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    const sdk: NodeSDK | undefined = await buildNodeInstrumentation(config);
 
     assert.ok(sdk);
 
     const _configuration = sdk["_configuration"];
 
     const logRecordProcessors = _configuration.logRecordProcessors;
-    assert.equal(logRecordProcessors.length, 2);
-    assert.ok(logRecordProcessors[1] instanceof SimpleLogRecordProcessor);
+    assert.equal(logRecordProcessors.length, 1);
+    assert.ok(
+      logRecordProcessors[logRecordProcessors.length - 1] instanceof
+        SimpleLogRecordProcessor,
+    );
+    assert.ok(
+      logRecordProcessors[logRecordProcessors.length - 1][
+        "_exporter"
+      ] instanceof PIIExporterDecorator,
+    );
   });
 
   test("check if clear base endpoint final slash", () => {
@@ -149,4 +182,9 @@ describe("verify config settings", () => {
 
     expect(config.collectorUrl).toBe("http://example.com");
   });
+
+  afterAll(() => {
+    // shutdown every instrumentation
+    process.emit("SIGTERM");
+  });
 });

package/test/processor/enrich-span-processor.test.ts

@@ -1,59 +1,7 @@
-import {
-  AttributeValue,
-  Context,
-  Exception,
-  Link,
-  Span,
-  SpanAttributes,
-  SpanContext,
-  SpanStatus,
-  TimeInput,
-} from "@opentelemetry/api";
+import { Context } from "@opentelemetry/api";
 import { describe, expect, it } from "vitest";
 import { EnrichSpanProcessor } from "../../lib/processor/enrich-span-processor.js";
-
-class MockSpan implements Span {
-  public attributes: Record<string, AttributeValue> = {};
-
-  spanContext(): SpanContext {
-    throw new Error("Method not implemented.");
-  }
-  setAttribute(key: string, value: AttributeValue): this {
-    this.attributes[key] = value;
-    return this;
-  }
-  setAttributes(attributes: SpanAttributes): this {
-    throw new Error("Method not implemented.");
-  }
-  addEvent(
-    name: string,
-    attributesOrStartTime?: SpanAttributes | TimeInput,
-    startTime?: TimeInput,
-  ): this {
-    throw new Error("Method not implemented.");
-  }
-  addLink(link: Link): this {
-    throw new Error("Method not implemented.");
-  }
-  addLinks(links: Link[]): this {
-    throw new Error("Method not implemented.");
-  }
-  setStatus(status: SpanStatus): this {
-    throw new Error("Method not implemented.");
-  }
-  updateName(name: string): this {
-    throw new Error("Method not implemented.");
-  }
-  end(endTime?: TimeInput): void {
-    throw new Error("Method not implemented.");
-  }
-  isRecording(): boolean {
-    throw new Error("Method not implemented.");
-  }
-  recordException(exception: Exception, time?: TimeInput): void {
-    throw new Error("Method not implemented.");
-  }
-}
+import { MockSpan } from "../utils/mock-signals.js";
 
 describe("EnrichSpanProcessor", () => {
   it("should set static attributes on span", () => {

package/test/resource.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, test, expect } from "vitest";
 import { ObservabilityResourceDetector } from "../lib/resource";
 
 describe("ObservabilityResourceDetector", () => {
@@ -19,4 +19,15 @@ describe("ObservabilityResourceDetector", () => {
     expect(result.attributes!["o11y.sdk.name"]).eq("@ogcio/o11y-sdk-node");
     expect(result.attributes).toHaveProperty("o11y.sdk.version");
   });
+
+  test("should return default resource attribute", () => {
+    const detector = new ObservabilityResourceDetector();
+    const result = detector.detect();
+
+    expect(result.attributes).not.toBeNull();
+    // default
+    expect(result.attributes).toHaveProperty("o11y.sdk.name");
+    expect(result.attributes!["o11y.sdk.name"]).eq("@ogcio/o11y-sdk-node");
+    expect(result.attributes).toHaveProperty("o11y.sdk.version");
+  });
 });

package/test/traces/active-span.test.ts

@@ -0,0 +1,28 @@
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import * as piiDetection from "../../lib/internals/pii-detection.js";
+import { getActiveSpan } from "../../lib/traces.js";
+import { MockSpan } from "../utils/mock-signals.js";
+import { setNodeSdkConfig } from "../../lib/config-manager.js";
+
+describe("getActiveSpan", () => {
+  it("returns undefined if no active span", async () => {
+    setNodeSdkConfig({
+      serviceName: "unit-test",
+      collectorUrl: "http://collector",
+      detection: {
+        email: false,
+      },
+    });
+
+    // Temporarily override
+    const opentelemetry = await import("@opentelemetry/api");
+
+    vi.spyOn(opentelemetry.trace, "getActiveSpan").mockImplementationOnce(
+      () => undefined,
+    );
+
+    const span = getActiveSpan();
+
+    expect(span).toBeUndefined();
+  });
+});

package/test/traces/with-span.test.ts

@@ -0,0 +1,340 @@
+import { Span, SpanOptions, SpanStatusCode, trace } from "@opentelemetry/api";
+import { TraceState } from "@opentelemetry/core";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import {
+  InMemorySpanExporter,
+  SimpleSpanProcessor,
+  SpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { setNodeSdkConfig } from "../../lib/config-manager.js";
+import { getActiveSpan, withSpan } from "../../lib/traces.js";
+
+describe("withSpan", () => {
+  let memoryExporter: InMemorySpanExporter;
+  let spanProcessor: SpanProcessor;
+  let sdk: NodeSDK;
+
+  beforeAll(() => {
+    memoryExporter = new InMemorySpanExporter();
+    spanProcessor = new SimpleSpanProcessor(memoryExporter);
+    sdk = new NodeSDK({
+      spanProcessors: [spanProcessor],
+      instrumentations: [],
+    });
+
+    setNodeSdkConfig({
+      collectorUrl: "http://localhost:4317",
+    });
+    sdk.start();
+  });
+
+  afterEach(async () => {
+    // Flush any remaining spans
+    await spanProcessor.forceFlush();
+    // Clean up
+    memoryExporter.reset();
+  });
+
+  afterAll(async () => {
+    await sdk.shutdown();
+  });
+
+  it("should handle simple synchronous usage", async ({}) => {
+    let capturedSpan: Span;
+
+    await withSpan({
+      spanName: "test-sync-span",
+      fn: (span: Span) => {
+        capturedSpan = span;
+      },
+    });
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].name).toBe("test-sync-span");
+    expect(spans[0].status.code).toBe(SpanStatusCode.OK);
+    expect(capturedSpan).toBeTruthy();
+    expect(capturedSpan.spanContext().traceId).toBe(
+      spans[0].spanContext().traceId,
+    );
+  });
+
+  it("should handle synchronous functions that throw errors", async ({}) => {
+    const error = new Error("Sync error");
+
+    await expect(
+      withSpan({
+        spanName: "test-sync-error-span",
+        fn: () => {
+          throw error;
+        },
+      }),
+    ).rejects.toThrow(error.message);
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].name).toBe("test-sync-error-span");
+    expect(spans[0].status.code).toBe(SpanStatusCode.ERROR);
+    expect(spans[0].status.message).toBe(error.message);
+    expect(spans[0].events).toHaveLength(1);
+    expect(spans[0].events[0].name).toBe("exception");
+  });
+
+  it("should handle asynchronous functions correctly", async ({}) => {
+    let capturedSpan: Span;
+
+    await withSpan({
+      spanName: "test-async-span",
+      fn: async (span: Span) => {
+        capturedSpan = span;
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        return "async-result";
+      },
+    });
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].name).toBe("test-async-span");
+    expect(spans[0].status.code).toBe(SpanStatusCode.OK);
+    expect(capturedSpan).toBeTruthy();
+    expect(capturedSpan.spanContext().traceId).toBe(
+      spans[0].spanContext().traceId,
+    );
+  });
+
+  it("should handle asynchronous functions that reject", async () => {
+    const error = new Error("Async error");
+
+    await expect(
+      withSpan({
+        spanName: "test-async-error-span",
+        fn: async () => {
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          throw error;
+        },
+      }),
+    ).rejects.toThrow(error.message);
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].name).toBe("test-async-error-span");
+    expect(spans[0].status.code).toBe(SpanStatusCode.ERROR);
+    expect(spans[0].status.message).toBe(error.message);
+    expect(spans[0].events).toHaveLength(1);
+    expect(spans[0].events[0].name).toBe("exception");
+  });
+
+  it("should handle non-Error exceptions", async () => {
+    const nonErrorException = { message: "Not an error object", code: 500 };
+
+    await expect(
+      withSpan({
+        spanName: "test-non-error-span",
+        fn: () => {
+          throw nonErrorException;
+        },
+      }),
+    ).rejects.toEqual(nonErrorException);
+
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].status.code).toBe(SpanStatusCode.ERROR);
+    expect(spans[0].status.message).toBe(JSON.stringify(nonErrorException));
+    expect(spans[0].events).toHaveLength(1);
+    expect(spans[0].events[0].name).toBe("exception");
+  });
+
+  it("should ensure span is ended even when errors occur", async () => {
+    const error = new Error("Test error");
+
+    await expect(
+      withSpan({
+        spanName: "test-finally-span",
+        fn: () => {
+          throw error;
+        },
+      }),
+    ).rejects.toThrow("Test error");
+
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].ended).toBe(true);
+  });
+
+  it("should pass span options to tracer", async () => {
+    const spanOptions: SpanOptions = {
+      attributes: { "custom.attribute": "custom-value" },
+      kind: 1,
+    };
+
+    await withSpan({
+      spanName: "test-options-span",
+      spanOptions,
+      fn: () => "result",
+    });
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].attributes["custom.attribute"]).toBe("custom-value");
+    expect(spans[0].kind).toBe(1);
+  });
+
+  it("should use custom tracer name", async () => {
+    const customTracerName = "custom-tracer";
+
+    await withSpan({
+      traceName: customTracerName,
+      spanName: "test-custom-tracer-span",
+      fn: () => "result",
+    });
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].name).toBe("test-custom-tracer-span");
+    expect(spans[0].instrumentationScope.name).toBe(customTracerName);
+  });
+
+  it("should use default tracer name when not specified", async () => {
+    await withSpan({
+      spanName: "test-default-tracer-span",
+      fn: () => "result",
+    });
+
+    await spanProcessor.forceFlush();
+    const defaultSpans = memoryExporter.getFinishedSpans();
+    expect(defaultSpans).toHaveLength(1);
+    expect(defaultSpans[0].name).toBe("test-default-tracer-span");
+    expect(defaultSpans[0].instrumentationScope.name).toBe("o11y-sdk");
+
+    memoryExporter.reset();
+
+    setNodeSdkConfig({
+      collectorUrl: "",
+      serviceName: "test-service",
+      serviceVersion: "v1.0.0",
+    });
+
+    await withSpan({
+      spanName: "test-default-tracer-span",
+      fn: () => "result",
+    });
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(spans[0].name).toBe("test-default-tracer-span");
+    expect(spans[0].instrumentationScope.name).toBe("test-service");
+    expect(spans[0].instrumentationScope.version).toBe("v1.0.0");
+  });
+
+  it("should allow function to interact with span context", async () => {
+    let receivedSpan: Span;
+
+    await withSpan({
+      spanName: "test-span-context",
+      fn: (span: Span) => {
+        receivedSpan = span;
+        span.spanContext().traceState = new TraceState(
+          "alpha=aaaaaaaaaaaa,bravo=bbbbbbbbbbbb",
+        );
+      },
+    });
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(1);
+    expect(receivedSpan).toBeTruthy();
+    expect(receivedSpan.spanContext().traceId).toBe(
+      spans[0].spanContext().traceId,
+    );
+    expect(receivedSpan.spanContext().spanId).toBe(
+      spans[0].spanContext().spanId,
+    );
+    expect(spans[0].spanContext().traceState.serialize()).toStrictEqual(
+      "alpha=aaaaaaaaaaaa,bravo=bbbbbbbbbbbb",
+    );
+  });
+
+  it("should preserve context across setTimeout", async () => {
+    await withSpan({
+      spanName: "test-timeout-context",
+      fn: async (span: Span) => {
+        return new Promise((resolve) => {
+          setTimeout(() => {
+            getActiveSpan().addEvent("promise-resolved", {
+              result: "timeout-result",
+            });
+            resolve("timeout-result");
+          }, 10);
+        });
+      },
+    });
+
+    let newSpan: Span;
+    await trace
+      .getTracer("some-tracer")
+      .startActiveSpan("other-context", async (span) => {
+        newSpan = span;
+        span.addEvent("other-context-event", {
+          result: "other-context-result",
+        });
+      });
+
+    newSpan.addEvent("another-context-event", {
+      result: "another-context-result",
+    });
+    newSpan.setStatus({ code: SpanStatusCode.OK });
+    newSpan.end();
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(2);
+
+    const timeoutSpan = spans.find((s) => s.name === "test-timeout-context");
+    expect(timeoutSpan.status.code).toBe(SpanStatusCode.OK);
+    expect(timeoutSpan.events).toHaveLength(1);
+    expect(timeoutSpan.events[0].name).toStrictEqual("promise-resolved");
+
+    const otherTrackedSpan = spans.find((s) => s.name === "other-context");
+    expect(otherTrackedSpan.status.code).toBe(SpanStatusCode.OK);
+    expect(otherTrackedSpan.events).toHaveLength(2);
+    expect(otherTrackedSpan.events[0].name).toStrictEqual(
+      "other-context-event",
+    );
+    expect(otherTrackedSpan.events[1].name).toStrictEqual(
+      "another-context-event",
+    );
+  });
+
+  it("should handle nested spans correctly", async () => {
+    await withSpan({
+      spanName: "outer-span",
+      fn: async () => {
+        await withSpan({
+          spanName: "inner-span",
+          fn: async () => {
+            await new Promise((resolve) => setTimeout(resolve, 1));
+          },
+        });
+      },
+    });
+
+    await spanProcessor.forceFlush();
+    const spans = memoryExporter.getFinishedSpans();
+    expect(spans).toHaveLength(2);
+
+    const innerSpan = spans.find((s) => s.name === "inner-span");
+    const outerSpan = spans.find((s) => s.name === "outer-span");
+
+    expect(innerSpan).toBeTruthy();
+    expect(outerSpan).toBeTruthy();
+    expect(innerSpan!.parentSpanContext.spanId).toBe(
+      outerSpan!.spanContext().spanId,
+    );
+  });
+});

package/test/utils/alloy-log-parser.ts

@@ -40,6 +40,13 @@ export function parseLog(
       // Additional metadata at the end, store it separately
       jsonObject["metadata"] = line;
     }
+
+    if (line.includes("Body:")) {
+      const match = line.match(/Body:\s+(\w+)\((.+)\)/);
+      if (match) {
+        jsonObject["log_body"] = match[2];
+      }
+    }
   });
 
   return jsonObject;