@grepr/cli 1.8.5-ca825ac → 1.8.7-20abddf

package/build/dist/docs-index/82d06166-701a-4d31-926c-8a1641a1c5a7.json

@@ -0,0 +1 @@
+{"docType":"doc"}

package/build/dist/docs-index/82d06166-701a-4d31-926c-8a1641a1c5a7.txt

@@ -0,0 +1,326 @@
+Learn how to create and use a New Relic integration to ingest logs to a Grepr pipeline for processing and send the processed logs to your New Relic instance.
+
+# Configure New Relic connections with a Grepr integration
+
+The New Relic integration enables you to ingest logs into Grepr with a Grepr source, process them with a Grepr pipeline, and then send the processed logs to New Relic with a Grepr sink.
+
+To send logs to a Grepr pipeline before forwarding the logs to New Relic, you change your collector configuration to send the logs to a Grepr endpoint URL instead of a New Relic endpoint. The Grepr New Relic integration supports the Fluent Bit and Fluentd collectors.
+
+You can use the Grepr UI or REST API to add a New Relic integration. To learn how to create a New Relic integration in the Grepr UI and configure collectors to send logs to Grepr, see [Use a New Relic integration in a Grepr pipeline](#use-newrelic-integration).
+
+To use the REST API, see the [New Relic Integration specification](/apis/api-spec#tag/New-Relic-Integration).
+
+> Although this page describes using an integration to create a pipeline for sourcing and sending data with a single observability platform, your pipelines can use multiple integrations to source and sink data for different platforms. For example, you can create a pipeline with a Datadog integration that's used to source data from Datadog agents, and a Splunk integration and sink that sends the pipeline output to Splunk.
+
+## Requirements
+
+* To create a New Relic integration, you must have a license key from your New Relic account. Use the same license key as the collectors that forward logs to New Relic. This key is required to authenticate the connection between Grepr and New Relic.
+* Optional: To enable Grepr's automatic exception parsing feature, you must have the Account ID and a user key from your New Relic account. See [Enable selective reduction with a New Relic integration](#enable-selective-reduction). The user key must match the one used by the New Relic collectors.
+
+## Enable selective reduction with a New Relic integration \[#enable-selective-reduction]
+
+When you include a New Relic user key and account ID in your integration configuration, Grepr automatically tracks dashboards and alerts configured in your New Relic account. By parsing queries used in these dashboards and alerts and making them available as exceptions to the log reducer, Grepr can determine which messages should not be processed.
+
+To learn more about viewing parsed queries and determining which should be used as exceptions, see [Identify log events that should bypass aggregation](/integrations#passthrough-estimation).
+
+To learn more about Grepr log reduction, see [Reduce shipped data volumes with the Grepr log reducer](/transforms/reducer).
+
+## Use a New Relic integration in a Grepr pipeline \[#use-newrelic-integration]
+
+To create a New Relic integration in the Grepr UI and use it in a pipeline to source and sink data, follow these steps:
+
+### Step 1: Create a New Relic integration
+
+To create a New Relic integration in the Grepr UI:
+
+1. Go to the **Integrations** page in the Grepr UI and click **Add new** next to **Observability Vendors**.
+
+2. In the **Add Observability Vendor** dialog:
+
+   * In the **Type** menu, select **New Relic**.
+   * In the **Name** field, enter a name for the integration.
+   * In the **License Key** field, enter the license key from your New Relic account. Use the same license key as the collectors that forward logs to New Relic. Do not enter a user key in this field.
+   * Optional: Enter the **Account ID** for your New Relic account. This value is only required if you choose to enable Grepr's automatic exception parsing feature.
+   * Optional: In the **User Key** field, enter a New Relic user key. Use the same user key that the New Relic collectors use. This value is only required if you choose to enable Grepr's automatic exception parsing feature.
+   * Optional: Specify how recently a dashboard must have been accessed to be included in automatic exception parsing. By default, Grepr checks for activity within the last 28 days.
+
+3. Click **Create**.
+
+   #### Optional: Grant team access to the integration
+
+   When you have teams in your Grepr organization, you can grant access to the integration to one or more of those teams. To configure team access when you create or edit an integration:
+
+   1. In the **Grant Team Access** section, click the plus sign icon (+).
+
+   2. Select the team or teams that should be granted access to the integration.
+
+   3. Click **Create**.
+
+   To learn more, see [Manage teams in the Grepr platform](/admin/manage-teams) and [Permissions in the Grepr platform](/grepr-platform/permissions).
+
+### Step 2: Add a source to your pipeline
+
+To add a source to your pipeline that uses the New Relic integration:
+
+1. In the Grepr UI, go to the details page for an existing pipeline or create a new pipeline from the homepage.
+2. In the left-hand navigation menu on the pipeline details page, click **Sources**.
+3. In the **Add source** dialog, select the New Relic integration in the **Source** menu.
+4. Click **Submit**.
+
+### Step 3: Configure log forwarding to Grepr \[#configure-forwarding-to-grepr]
+
+To send data to Grepr, you configure your collector or agent to send it to the ingestion URL for your Grepr integration, rather than to your observability vendor's platform. To find the ingestion URL when using the Grepr UI to configure your pipeline, go to the details page for the pipeline, click **Sources** in the left pane, and copy the **Ingest URL**.
+
+
+
+If you connect to Grepr through AWS PrivateLink, copy the private ingestion URL and use it in place of the public ingestion URL. To learn more about sending data to Grepr over AWS PrivateLink, see [Securely forward observability data to Grepr with AWS PrivateLink](/admin/private-link).
+
+When you use the API, you can construct the ingestion URL using the following format:
+
+`https://<integration-id>-<org-id>.ingest.grepr.ai/nr/log/v1`
+
+Replace `<integration-id>` with the identifier of the vendor integration used by your pipeline and replace `<org-id>` with the identifier for your organization.
+
+To use the PrivateLink endpoint service, insert `.private` after the `ingest` host segment.
+
+Although all sources created from the same integration share the same ingestion URL, you can use a single integration to create sources for multiple pipelines. The Grepr platform ensures events are routed to the correct pipelines.
+
+To see more information and configuration examples, select the tab for your preferred log collector:
+
+Fluent Bit can forward logs using the New Relic output plugin. To configure the plugin, set the `endpoint` value to the ingestion URL from your integration and the `licenseKey` value to your New Relic license key. The following is an example `OUTPUT` section from a Fluent Bit configuration file (`fluent-bit.conf`):
+
+```fluent
+[OUTPUT]
+    Name       newrelic
+    Match      *
+    licenseKey <nr-license-key>
+    endpoint   <ingestion-url>
+```
+
+Replace:
+
+* `<nr-license-key>` with your New Relic license key.
+* `<ingestion-url>` with the ingestion URL from your New Relic integration.
+
+Fluent Bit can also be configured to dual-ship logs to New Relic and Grepr. To do this, add another `[OUTPUT]` section to the `fluent-bit.conf` file for New Relic.
+
+> The New Relic Fluent Bit output plugin supports only a single output configuration per license key. To dual-ship logs, you must use a different license key for the Grepr output configuration.
+
+```fluent
+# Send logs to New Relic directly
+[OUTPUT]
+    Name       newrelic
+    Match      *
+    licenseKey <nr-license-key>
+
+# Send logs to Grepr (must use a different license key)
+[OUTPUT]
+    Name       newrelic
+    Match      *
+    licenseKey <nr-license-key-for-grepr>
+    endpoint   <ingestion-url>
+```
+
+To learn more about configuration settings for Fluent Bit, see the documentation for the [Fluent Bit New Relic output plugin](https://docs.fluentbit.io/manual/pipeline/outputs/new-relic).
+
+Fluentd can forward logs to Grepr using the `fluent-plugin-newrelic` output plugin. To configure the plugin, add a `match` directive to the Fluentd configuration. The following is an example `match` directive from a Fluentd configuration file (`fluentd.conf`):
+
+```fluent
+<match your_tag.**> # Adjust your match pattern as needed
+  @type newrelic
+  license_key <nr-license-key>
+  base_uri <ingestion-url>
+</match>
+```
+
+Replace:
+
+* `your_tag.**` with the tag of the logs you want to forward to Grepr, or use `**` to match all tags.
+* `<nr-license-key>` with your New Relic license key.
+* `<ingestion-url>` with the ingestion URL from your New Relic integration.
+
+To dual-ship logs, use the `copy` output plugin:
+
+```fluent
+<match your_tag.**>
+  @type copy
+  <store>
+    @type newrelic
+    license_key <nr-license-key>
+    base_uri <ingestion-url>
+  </store>
+  <store>
+    @type newrelic
+    license_key <nr-license-key>
+  </store>
+</match>
+```
+
+To learn more about configuration settings for Fluentd, see the documentation for the [Fluentd New Relic output plugin](https://github.com/newrelic/newrelic-fluentd-output#readme).
+
+## Migrate AWS logging from CloudWatch to New Relic with Grepr \[#migrate-aws-cloudwatch]
+
+If your AWS services currently send logs to Amazon CloudWatch before forwarding them to New Relic, you can reduce your CloudWatch ingestion and storage costs by forwarding them to Grepr instead. This section describes how to configure common AWS services to forward logs to a Grepr pipeline for processing before delivering them to New Relic.
+
+Forwarding your AWS logs to New Relic with Grepr requires a New Relic integration. If you need to create a New Relic integration, see [Use a New Relic integration in a Grepr pipeline](#use-newrelic-integration).
+
+Although the changes vary depending on the AWS service, forwarding your AWS logs uses one of the following New Relic tools:
+
+* The [New Relic Lambda extension](https://github.com/newrelic/newrelic-lambda-extension) forwards Lambda function logs to a destination, such as your Grepr integration.
+* The [New Relic Fluent Bit output plugin](https://github.com/newrelic/newrelic-fluent-bit-output) forwards Amazon ECS container logs through AWS FireLens.
+* For services without a specific tool to forward logs to New Relic, you configure the service to write to Amazon S3 and then use the [New Relic S3 log forwarder Lambda](https://github.com/newrelic/aws_s3_log_ingestion_lambda).
+
+To see instructions for a specific AWS service, select the tab for that service:
+
+To forward Lambda function logs directly to Grepr for processing and forwarding to New Relic, use the [New Relic Lambda extension](https://github.com/newrelic/newrelic-lambda-extension). Use the following steps to install and configure the extension to forward logs to a source created from a Grepr New Relic integration:
+
+1. To install the extension, follow the **Installation** instructions in the [newrelic-lambda-extension README](https://github.com/newrelic/newrelic-lambda-extension/blob/main/README.md).
+
+2. Set the following environment variables for the function:
+
+   \| Variable | Value | |---|---| | `NEW_RELIC_LOG_ENDPOINT` | The Grepr ingestion URL for your New Relic integration. To find the ingestion URL, see [Step 3: Configure log forwarding to Grepr](#configure-forwarding-to-grepr). | | `NEW_RELIC_EXTENSION_SEND_FUNCTION_LOGS` | `true` | | `NEW_RELIC_EXTENSION_SEND_EXTENSION_LOGS` | Optional. Set to `true` to forward the extension's logs in addition to the function logs. |
+
+3. To stop sending the function's logs to CloudWatch, remove the `logs:CreateLogGroup`, `logs:CreateLogStream`, and `logs:PutLogEvents` permissions from the function's IAM execution role. To learn more about Lambda execution roles, see [Defining Lambda function permissions with an execution role](https://docs.aws.amazon.com/lambda/latest/dg/lambda-intro-execution-role.html).
+
+Because Lambda\@Edge does not support Lambda extensions, you cannot use the New Relic Lambda extension to forward Lambda\@Edge logs. Instead, instrument your Lambda\@Edge function to write batched logs directly to an Amazon S3 bucket and then forward the logs from S3 with the New Relic S3 log forwarder Lambda.
+
+To migrate Lambda\@Edge logging:
+
+1. Update your Lambda\@Edge function to write log records to an S3 bucket as newline-delimited text or NDJSON. To reduce per-invocation overhead, batch records in memory and write them as larger objects. To learn more, including the configuration and required permissions for your functions, see [Customizing at the edge with Lambda@Edge](https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-at-the-edge.html).
+2. Configure the S3 bucket as a source for the New Relic S3 log forwarder Lambda. See the **Other AWS services through S3** tab.
+
+Use the [AWS FireLens log driver](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html) with the [Fluent Bit New Relic output plugin](https://docs.fluentbit.io/manual/pipeline/outputs/new-relic) to forward Amazon ECS container logs directly to Grepr. Because Fluent Bit forwards logs directly, no CloudWatch or S3 infrastructure is required.
+
+To migrate logging for an ECS service:
+
+1. Update each ECS task definition to use the `awsfirelens` log driver and run a Fluent Bit log router container. To learn more about FireLens task definitions, see [Custom log routing](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html).
+
+2. Provide the log router container with a Fluent Bit configuration that includes a `[OUTPUT]` section for the New Relic plugin.
+
+   ```fluent
+   [OUTPUT]
+       Name       newrelic
+       Match      *
+       licenseKey <nr-license-key>
+       endpoint   <ingestion-url>
+   ```
+
+   Replace:
+
+   * `<nr-license-key>` with your New Relic license key.
+   * `<ingestion-url>` with the Grepr ingestion URL for your New Relic integration. To find the ingestion URL, see [Step 3: Configure log forwarding to Grepr](#configure-forwarding-to-grepr).
+
+To learn more about loading a custom Fluent Bit configuration with FireLens, see [Custom log routing configuration](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/firelens-taskdef.html).
+
+Amazon API Gateway does not support writing access logs directly to S3. Instead, you can deliver the logs to S3 through an Amazon Data Firehose delivery stream and then forward them from S3 with the New Relic S3 log forwarder Lambda.
+
+To migrate API Gateway access logging:
+
+1. Create an Amazon Data Firehose delivery stream that writes to an S3 bucket. The delivery stream name must begin with `amazon-apigateway-` to prevent API Gateway from rejecting it as an access log destination. In the destination configuration, enable the newline delimiter between records so the stream writes log files in NDJSON format. To learn more about creating a delivery stream with an S3 destination, see [Choose Amazon S3 for your destination](https://docs.aws.amazon.com/firehose/latest/dev/create-destination.html#create-destination-s3).
+2. Update your API Gateway stage to send access logs to the Firehose delivery stream by setting the stream ARN as the access log destination. To learn more about access log settings, see [AccessLogSettings](https://docs.aws.amazon.com/apigateway/latest/api/API_AccessLogSettings.html) in the API Gateway API reference.
+3. Configure the S3 bucket as a source for the New Relic S3 log forwarder Lambda. See the **Other AWS services through S3** tab.
+
+For all other AWS services that support writing logs directly to S3, configure them to write logs to an S3 bucket and then use the [AWS Lambda for forwarding logs from S3](https://github.com/newrelic/aws_s3_log_ingestion_lambda) to send the logs to Grepr. The forwarder reads newline-delimited text, NDJSON, and CloudTrail JSON files, automatically decompresses gzip-compressed objects, and batches log events before sending them.
+
+To set up the Lambda function to forward logs from S3 to Grepr:
+
+1. Deploy the function from the AWS Serverless Application Repository or by deploying its SAM template. To learn more about deploying the forwarder, see [AWS Lambda for sending logs from S3](https://docs.newrelic.com/docs/logs/forward-logs/aws-lambda-sending-logs-s3/).
+
+2. Set the following environment variables on the deployed Lambda function:
+
+   \| Variable | Value | |---|---| | `LICENSE_KEY` | Your New Relic license key. Use the same key configured in your Grepr New Relic integration. | | `NR_LOGGING_ENDPOINT` | The Grepr ingestion URL for your New Relic integration. |
+
+3. Configure the Lambda to be invoked when new log objects arrive in the S3 bucket. To learn more about Lambda triggers for S3, see [Using an Amazon S3 trigger to invoke a Lambda function](https://docs.aws.amazon.com/lambda/latest/dg/with-s3-example.html).
+
+To minimize cost and operational overhead, Grepr recommends the following:
+
+* Write logs from all services to the same S3 bucket and prefix, and use a single forwarder deployment to handle all of them.
+* Add an S3 lifecycle rule that expires log objects after one day. To learn more about lifecycle rules, see [Setting lifecycle configuration on a bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html).
+
+The following AWS services are compatible with the Lambda forwarder. For each service, ensure that logs are output in the supported S3 log format. To learn more, see the AWS documentation links for each service.
+
+| Service | S3 log format | AWS documentation | Notes |
+| --- | --- | --- | --- |
+| AWS CloudTrail | JSON | [Creating a trail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-a-trail-using-the-console-first-time.html) | S3 is the default destination. Disable any CloudWatch Logs delivery configured on the trail. |
+| VPC Flow Logs | Newline-delimited text | [Publishing flow logs to Amazon S3](https://docs.aws.amazon.com/vpc/latest/userguide/flow-logs-s3.html) | Select the text log file format. The forwarder does not read Parquet files. |
+| AWS WAF | NDJSON | [Logging AWS WAF web ACL traffic](https://docs.aws.amazon.com/waf/latest/developerguide/logging.html) | |
+| Amazon Route 53 Resolver query logs | NDJSON | [Managing Resolver query logging configurations](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resolver-query-logs-configurations.html) | Public hosted zone query logs do not support S3 as a direct destination. |
+| Amazon MSK Provisioned | Newline-delimited text | [Broker log delivery](https://docs.aws.amazon.com/msk/latest/developerguide/msk-logging.html) | Changing the broker log configuration triggers a rolling broker restart. |
+| Amazon Bedrock | NDJSON | [Monitor model invocation using Amazon CloudWatch Logs](https://docs.aws.amazon.com/bedrock/latest/userguide/model-invocation-logging.html) | |
+| Amazon EMR | Newline-delimited text | [Configure cluster logging and debugging](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-debugging.html) | The S3 log URI can only be set at cluster creation. |
+| AWS Elastic Beanstalk | Newline-delimited text | [Streaming instance logs to Amazon S3](https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/AWSHowTo.cloudwatchlogs.html#AWSHowTo.cloudwatchlogs.streaming) | |
+| Amazon API Gateway | NDJSON | See the **API Gateway** tab | Requires an Amazon Data Firehose delivery stream with the newline delimiter enabled. |
+
+## Limitations
+
+* The New Relic integration supports only HTTP/HTTPS connections. TCP connections are not supported.
+
+## Frequently Asked Questions
+
+### How do I send logs from New Relic to Grepr for processing?
+
+To send logs to Grepr before forwarding to New Relic, configure your collector to send logs to the Grepr ingestion URL instead of the New Relic endpoint. The ingestion URL format is https\://\<integration-id>-\<org-id>.ingest.grepr.ai/nr/log/v1. You can use Fluent Bit or Fluentd collectors configured with the New Relic output plugin.
+
+### What authentication credentials do I need for the New Relic integration?
+
+You need a license key from your New Relic account for log ingestion. Optionally, to enable automatic exception parsing, you also need your New Relic Account ID and a user key. The user key must match the one your collectors use for authentication.
+
+### How do I configure Fluent Bit to send logs to Grepr with a New Relic integration?
+
+In your Fluent Bit configuration, create an OUTPUT section with Name set to 'newrelic', set the licenseKey to your New Relic license key, and set the endpoint to your Grepr ingestion URL. You can also configure multiple OUTPUT sections to dual-ship logs to both Grepr and New Relic directly.
+
+### What is the automatic exception parsing feature for New Relic?
+
+When you configure your New Relic integration with a user key and Account ID, Grepr automatically tracks dashboards and alerts in your New Relic account. Grepr parses the queries used in these dashboards and alerts and makes them available as exceptions to the log reducer, helping identify which messages should not be processed.
+
+### How do I enable selective log reduction with New Relic?
+
+Provide your New Relic Account ID and user key when creating the integration. Grepr will automatically sync with your New Relic dashboards and alerts. You can view the list of parsed exceptions by clicking the cloud sync icon under Actions on the Integrations page.
+
+### How do I configure Fluentd to send logs to Grepr with a New Relic integration?
+
+Add a match directive to your Fluentd configuration with @type set to 'newrelic', license_key set to your New Relic license key, and base_uri set to your Grepr ingestion URL. For dual-shipping, use the copy output plugin with multiple store sections for different destinations.
+
+### Can I use New Relic integration to send processed logs back to New Relic?
+
+Yes, you can add a sink to your Grepr pipeline that uses the New Relic integration. This allows logs to be ingested from New Relic sources, processed by Grepr pipelines, and then sent back to New Relic or other observability platforms.
+
+### What is the advantage of using automatic exception parsing with New Relic?
+
+Automatic exception parsing helps reduce log storage costs by identifying which log messages are tracked in your New Relic dashboards and alerts. The log reducer uses this information to avoid aggregating important messages while reducing redundant log volume, optimizing your observability costs.
+
+### How often does Grepr sync with my New Relic dashboards and alerts?
+
+You can specify how recently a dashboard must have been accessed to be included in automatic exception parsing. By default, Grepr checks for activity within the last 28 days, but you can adjust this setting when creating or updating your New Relic integration.
+
+### Can I use the New Relic integration without the automatic exception parsing feature?
+
+Yes, the automatic exception parsing feature is optional. You only need the license key to create and use a New Relic integration. The Account ID and user key are only required if you want to enable automatic exception parsing from your New Relic dashboards and alerts.
+
+### How do I reduce CloudWatch costs when forwarding AWS logs to New Relic?
+
+If your AWS services send logs to CloudWatch before forwarding them to New Relic, you can reduce CloudWatch ingestion and storage costs by forwarding the logs directly to a Grepr pipeline for processing and then on to New Relic. The setup varies by AWS service and uses one of three New Relic tools: the New Relic Lambda extension for AWS Lambda functions, the Fluent Bit New Relic output plugin with AWS FireLens for Amazon ECS container logs, or the New Relic S3 log forwarder Lambda for services that write logs to Amazon S3.
+
+### How do I forward AWS Lambda function logs directly to Grepr?
+
+Install the New Relic Lambda extension on your function, set the NEW_RELIC_LOG_ENDPOINT environment variable to your Grepr ingestion URL, and set NEW_RELIC_EXTENSION_SEND_FUNCTION_LOGS to true. To stop sending logs to CloudWatch, remove the logs:CreateLogGroup, logs:CreateLogStream, and logs:PutLogEvents permissions from the function's IAM execution role.
+
+### How do I forward Lambda\@Edge logs to Grepr?
+
+Lambda\@Edge does not support Lambda extensions, so the New Relic Lambda extension cannot be used. Instead, instrument your Lambda\@Edge function to write batched log records directly to an S3 bucket and then use the New Relic S3 log forwarder Lambda to send the logs from S3 to Grepr.
+
+### How do I forward Amazon ECS container logs to Grepr?
+
+Use the AWS FireLens log driver with the Fluent Bit New Relic output plugin. Update each ECS task definition to use the awsfirelens log driver and run a Fluent Bit log router container, then provide a Fluent Bit configuration with an OUTPUT section that sets Name to newrelic, endpoint to your Grepr ingestion URL, and licenseKey to your New Relic license key. No CloudWatch or S3 infrastructure is required.
+
+### How do I forward Amazon API Gateway access logs to Grepr?
+
+API Gateway cannot write access logs directly to S3, so deliver them to S3 through an Amazon Data Firehose delivery stream and then use the New Relic S3 log forwarder Lambda to send them to Grepr. The Firehose delivery stream name must begin with amazon-apigateway- for API Gateway to accept it as an access log destination, and the Firehose destination must have the newline delimiter enabled so the logs are written in NDJSON format.
+
+### Which AWS services can I forward logs from to Grepr through S3?
+
+The New Relic S3 log forwarder Lambda supports AWS CloudTrail, VPC Flow Logs, AWS WAF, Amazon Route 53 Resolver query logs, Amazon MSK Provisioned, Amazon Bedrock, Amazon EMR, AWS Elastic Beanstalk, and Amazon API Gateway. Configure each service to write logs to an S3 bucket in newline-delimited text, NDJSON, or CloudTrail JSON format, and the forwarder reads and ships them to Grepr.
+
+### What environment variables does the New Relic S3 log forwarder Lambda need to send logs to Grepr?
+
+Set LICENSE_KEY to your New Relic license key, using the same key configured in your Grepr New Relic integration, and set NR_LOGGING_ENDPOINT to the Grepr ingestion URL for that integration.

package/build/dist/docs-index/82dd6287-a6af-4cc1-bb0c-1487d67f18f8.json

@@ -0,0 +1 @@
+{"docType":"doc"}

package/build/dist/docs-index/82dd6287-a6af-4cc1-bb0c-1487d67f18f8.txt

@@ -0,0 +1,74 @@
+Automatically detect and parse JSON log messages into structured objects with fields added to log event attributes.
+
+# Transform JSON strings into JSON objects
+
+Grepr can automatically detect and parse JSON log messages into structured objects. All fields in the JSON object are parsed and added into the attributes of the log event. Using this along with the remapper transform allows you to enrich your logs. See [Remap JSON attribute fields to top-level log event fields](/transforms/remapper).
+
+This operation is automatically performed when creating a pipeline through the Grepr UI. However, it must be manually added in the Grepr job graph when creating a pipeline through the API.
+
+## Usage example
+
+Incoming log event:
+
+```json
+{
+  "message": "{\"msg\": \"Example log message\", \"@timestamp\": \"2007-12-03T10:15:30.00Z\", \"log\": {\"level\": \"INFO\"}}"
+}
+```
+
+Parsed log message:
+
+```json
+{
+  "message": "",
+  "attributes": {
+    "@timestamp": "2007-12-03T10:15:30.00Z",
+    "msg": "Example log message",
+    "log": {
+      "level": "INFO"
+    }
+  }
+}
+```
+
+## Frequently Asked Questions
+
+### What does the JSON parsing transform do?
+
+The JSON parsing transform automatically detects and parses JSON log messages into structured objects. All fields in the JSON object are parsed and added as attributes in the log event, converting unstructured JSON strings into queryable structured data.
+
+### When should I use JSON parsing?
+
+Use JSON parsing when your logs contain JSON-formatted messages or attributes that need to be converted to structured fields. This is useful for application logs that output JSON, cloud service logs, and any logs where you need to query nested JSON data.
+
+### Is JSON parsing applied automatically in Grepr pipelines?
+
+When creating a pipeline through the Grepr UI, JSON parsing is applied automatically. However, if you create a pipeline through the REST API, you must manually add JSON parsing as a vertex in the job graph.
+
+### How are nested JSON fields handled?
+
+Nested JSON fields are preserved as nested objects in the attributes. For example, a JSON field like 'log: { level: INFO }' becomes an attributes object with the same structure, allowing you to query nested data.
+
+### Can I combine JSON parsing with the Grok parser?
+
+Yes. You can use JSON parsing first to convert JSON strings to objects, then use the Grok parser to extract specific fields from parsed attributes, or use other transforms to further enrich or manipulate the data.
+
+### What happens to the original message field after JSON parsing?
+
+The original message field is cleared after JSON parsing because the JSON content has been parsed into attributes. If you need to retain the original message, use the remapper transform or include a copy of the message in your JSON payload.
+
+### How does JSON parsing handle malformed JSON?
+
+If a log message contains malformed JSON, it is passed through without parsing. The original message remains unchanged and is processed by subsequent transforms. This allows pipelines to handle mixed log formats gracefully.
+
+### Can I use JSON parsing with the remapper transform?
+
+Yes. You can use JSON parsing to parse JSON messages into attributes, then use the remapper transform to move or rename specific JSON fields to top-level log event fields for better querying and filtering.
+
+### What is the performance impact of JSON parsing?
+
+JSON parsing has minimal performance impact as it leverages efficient JSON libraries. Performance depends on the size and complexity of JSON objects. For high-volume, small JSON payloads, the impact is negligible.
+
+### How do I troubleshoot JSON parsing issues?
+
+Use live edit to test JSON parsing with sample logs. The Pipeline Log Viewer will show you the parsed attributes and help you verify that JSON is being parsed correctly. Check the transformation output to ensure nested structures are preserved as expected.

package/build/dist/docs-index/82f8e119-a664-4b28-9712-4046d3b140c4.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/82f8e119-a664-4b28-9712-4046d3b140c4.txt

@@ -0,0 +1,29 @@
+# SqlExecutable
+
+Base class for SQL statements
+
+**Type**: `object`
+
+## One Of
+
+This schema accepts one of the following types:
+
+### Option 1
+`SqlViewStatement`
+
+### Option 2
+`SqlOutputStatement`
+
+### Option 3
+`SqlIoStatement`
+
+## Properties
+
+- name: eventTimeAttribute (optional)
+  type: string
+
+- name: materialized (optional)
+  type: boolean
+
+- name: type (required)
+  type: string

package/build/dist/docs-index/82fdcd85-daf5-422f-b880-7c9827c7f2da.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/82fdcd85-daf5-422f-b880-7c9827c7f2da.txt

@@ -0,0 +1,12 @@
+# NotQueryNode
+
+**Type**: `object`
+
+## Properties
+
+- name: expression (required)
+  type: `ParsedQueryNode`
+
+- name: type (required)
+  type: enum: `not-query-node`
+  description: A node that represents a negation in a parsed query.

package/build/dist/docs-index/83319929-fbe2-44a7-baa4-4d17b030532a.json

@@ -0,0 +1 @@
+{"docType":"schema"}

package/build/dist/docs-index/83319929-fbe2-44a7-baa4-4d17b030532a.txt

@@ -0,0 +1,51 @@
+# ReducerLogsQuerySource
+
+**Type**: `object`
+
+## Properties
+
+- name: datasetId (required)
+  type: string
+  description: The ID of the dataset to read data from.
+
+- name: end (required)
+  type: string
+  description: End of time interval to query data for.
+
+- name: limit (optional)
+  type: integer
+  description: The maximum number of rows to process
+
+- name: name (required)
+  type: string
+
+- name: offset (optional)
+  type: integer
+  description: Offset on the number of rows to process
+
+- name: processedLogsTableName (optional)
+  type: string
+  description: The name of the table containing processed logs.
+
+- name: query (required)
+  type: `query`
+
+- name: reductionInterval (required)
+  type: string
+  description: The interval used by the Log Reducer for the query. Uses ISO 8601 format for intervals.
+
+- name: sortOrder (optional)
+  type: enum: `ASCENDING`, `DESCENDING`, `UNSORTED`
+  description: The order in which the rows should be sorted by
+
+- name: start (required)
+  type: string
+  description: Start of time interval to query data for.
+
+- name: type (required)
+  type: enum: `reducer-logs-iceberg-table-source`
+  description: Queries raw and processed logs from a reducer pipeline.
+
+- name: variables (optional)
+  type: object
+  description: Variables that can be used to modify the query while parsed

package/build/dist/docs-index/8373fd10-5635-48bb-8e78-7c967222fe42.json

@@ -0,0 +1 @@
+{"docType":"api"}

package/build/dist/docs-index/8373fd10-5635-48bb-8e78-7c967222fe42.txt

@@ -0,0 +1,20 @@
+# deleteUser
+
+**DELETE** `/v1/users/{id}`
+
+**Operation ID**: `deleteUser`
+**Summary**: No summary provided.
+## Tags
+- Users
+## Parameters
+
+- **id** (required) - path
+  - Type: string
+
+## Responses
+
+### default
+
+default response
+
+- **Content-Type**: `application/json` / No schema defined

package/build/dist/docs-index/83a69df8-424b-40d5-b303-3ca311e1410a.json

@@ -0,0 +1 @@
+{"docType":"doc"}