diff --git a/docs/concepts/otlp/index.mdx b/docs/concepts/otlp/index.mdx
index 69eb2be348ae5..624a00d206b63 100644
--- a/docs/concepts/otlp/index.mdx
+++ b/docs/concepts/otlp/index.mdx
@@ -250,3 +250,7 @@ The following SDKs have dedicated integrations that make OTLP setup easy:
     label="Python"
     url="/platforms/python/integrations/otlp"
   />
+
+## OpenTelemetry Collector Guides
+
+View the [OpenTelemetry Collector Guides](/product/drains/integration/opentelemetry-collector/#open-telemetry-collector-guides) to learn how to leverage the OpenTelemetry Collector to send traces and logs to Sentry from different sources like Kafka or Nginx.
diff --git a/docs/product/drains/integration/opentelemetry-collector.mdx b/docs/product/drains/integration/opentelemetry-collector.mdx
index 2bdd2f3dbc9d7..798f576fd09cb 100644
--- a/docs/product/drains/integration/opentelemetry-collector.mdx
+++ b/docs/product/drains/integration/opentelemetry-collector.mdx
@@ -137,3 +137,13 @@ service:
       receivers: [routing]
       exporters: [otlphttp/project-b]
 ```
+
+## OpenTelemetry Collector Guides
+
+These guides show you how to leverage the OpenTelemetry Collector to send traces and logs to Sentry from different sources.
+
+- [Forwarding AWS CloudWatch Logs to Sentry](/product/drains/otlp-guides/aws-cloudwatch/)
+- [Forwarding Logs and Traces from Kafka to Sentry](/product/drains/otlp-guides/kafka/)
+- [Forwarding Nginx Logs to Sentry](/product/drains/otlp-guides/nginx/)
+- [Forwarding Syslog Messages to Sentry](/product/drains/otlp-guides/syslog/)
+- [Forwarding Windows Event Logs to Sentry](/product/drains/otlp-guides/windows-events/)
diff --git a/docs/product/drains/otlp-guides/aws-cloudwatch.mdx b/docs/product/drains/otlp-guides/aws-cloudwatch.mdx
new file mode 100644
index 0000000000000..31bfac98f31f9
--- /dev/null
+++ b/docs/product/drains/otlp-guides/aws-cloudwatch.mdx
@@ -0,0 +1,199 @@
+---
+title: Forwarding AWS CloudWatch Logs to Sentry via the OpenTelemetry Protocol (OTLP)
+sidebar_order: 100
+description: "Learn how to forward AWS CloudWatch logs to Sentry via the OpenTelemetry Protocol (OTLP)."
+keywords:
+  ["otlp", "otel", "opentelemetry", "aws", "cloudwatch", "logs", "amazon"]
+---
+
+This guide shows you how to collect AWS CloudWatch logs and forward them to Sentry using the OpenTelemetry Collector with the [AWS CloudWatch Receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/awscloudwatchreceiver).
+
+## Prerequisites
+
+Before you begin, ensure you have:
+
+- AWS credentials configured with permissions to read CloudWatch logs
+- A Sentry project to send data to
+
+## Step 1: Install the OpenTelemetry Collector
+
+The AWS CloudWatch Receiver is included in the [OpenTelemetry Collector Contrib](https://github.com/open-telemetry/opentelemetry-collector-releases/tree/main/distributions/otelcol-contrib) distribution. You'll need to download and install this version, as the standard `otelcol` binary does not include the AWS CloudWatch Receiver.
+
+Download the latest `otelcol-contrib` binary from the [OpenTelemetry Collector releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases).
+
+## Step 2: Configure AWS Credentials
+
+The AWS CloudWatch Receiver uses the [AWS SDK](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html) for authentication, which supports multiple methods including credentials files and EC2 instance metadata (IMDS).
+
+### Using an AWS Credentials File
+
+Configure your AWS credentials using the AWS CLI:
+
+```bash
+aws configure
+```
+
+This creates a credentials file at `~/.aws/credentials` with your access key and secret.
+
+### Using IAM Role (EC2)
+
+For EC2 environments, attach an IAM role with the `CloudWatchLogsReadOnlyAccess` policy to your instance.
+
+### Required IAM Permissions
+
+Your AWS credentials need the following permissions:
+
+- `logs:DescribeLogGroups`
+- `logs:DescribeLogStreams`
+- `logs:GetLogEvents`
+
+## Step 3: Get Your Sentry OTLP Credentials
+
+You'll need your Sentry OTLP endpoint and authentication header. These can be found in your [Sentry Project Settings](https://sentry.io/settings/projects/) under **Client Keys (DSN)** > **OpenTelemetry (OTLP)**.
+
+### Logs Endpoint
+
+```bash
+___OTLP_LOGS_URL___
+```
+
+### Authentication Header
+
+```
+x-sentry-auth: sentry sentry_key=___PUBLIC_KEY___
+```
+
+## Step 4: Configure the Collector
+
+Create a configuration file with the AWS CloudWatch Receiver and the OTLP HTTP exporter configured to send logs to Sentry.
+
+For additional configuration options, see the [AWS CloudWatch Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/awscloudwatchreceiver).
+
+### Collect All Log Groups (Autodiscover)
+
+This configuration automatically discovers and collects logs from all CloudWatch log groups:
+
+```yaml {filename:config.yaml}
+receivers:
+  awscloudwatch:
+    region: us-east-1
+    logs:
+      poll_interval: 1m
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - awscloudwatch
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+### Collect Specific Log Groups by Prefix
+
+This configuration discovers log groups matching a specific prefix, useful for collecting logs from specific AWS services like EKS or Lambda:
+
+```yaml {filename:config.yaml}
+receivers:
+  awscloudwatch:
+    region: us-east-1
+    logs:
+      poll_interval: 1m
+      groups:
+        autodiscover:
+          limit: 100
+          prefix: /aws/lambda/
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - awscloudwatch
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+### Collect Named Log Groups
+
+This configuration collects logs from specific, named log groups:
+
+```yaml {filename:config.yaml}
+receivers:
+  awscloudwatch:
+    region: us-east-1
+    logs:
+      poll_interval: 1m
+      groups:
+        named:
+          /aws/lambda/my-function:
+          /aws/eks/my-cluster/cluster:
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - awscloudwatch
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+## Troubleshooting
+
+- Verify your AWS credentials are correctly configured and have the required permissions
+- Ensure the specified AWS region matches where your CloudWatch log groups are located
+- Check that the log group names or prefixes match existing CloudWatch log groups
+
+## Additional Resources
+
+- [AWS CloudWatch Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/awscloudwatchreceiver)
+- [AWS SDK Authentication](https://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html)
+- [Sentry OpenTelemetry Collector Configuration](/product/drains/integration/opentelemetry-collector/)
+- [Sentry Logs](/product/explore/logs/)
diff --git a/docs/product/drains/otlp-guides/kafka.mdx b/docs/product/drains/otlp-guides/kafka.mdx
new file mode 100644
index 0000000000000..95941f1219ec4
--- /dev/null
+++ b/docs/product/drains/otlp-guides/kafka.mdx
@@ -0,0 +1,195 @@
+---
+title: Forwarding Logs and Traces from Kafka to Sentry via the OpenTelemetry Protocol (OTLP)
+sidebar_order: 150
+description: "Learn how to forward traces and logs from Kafka to Sentry via the OpenTelemetry Protocol (OTLP)."
+keywords: ["otlp", "otel", "opentelemetry", "kafka", "logs", "traces"]
+---
+
+This guide shows you how to consume telemetry data (traces and logs) from Kafka topics and forward them to Sentry using the OpenTelemetry Collector with the [Kafka Receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/kafkareceiver).
+
+The Kafka Receiver is useful when you have applications publishing OTLP-formatted telemetry data to Kafka topics, allowing the OpenTelemetry Collector to consume and forward this data to Sentry.
+
+## Prerequisites
+
+Before you begin, ensure you have:
+
+- A Kafka cluster with telemetry data being published to topics
+- Network access to your Kafka brokers
+- A Sentry project to send data to
+
+## Step 1: Install the OpenTelemetry Collector
+
+The Kafka Receiver is included in both the [OpenTelemetry Collector Core](https://github.com/open-telemetry/opentelemetry-collector-releases/tree/main/distributions/otelcol) and [Contrib](https://github.com/open-telemetry/opentelemetry-collector-releases/tree/main/distributions/otelcol-contrib) distributions.
+
+Download the latest binary from the [OpenTelemetry Collector releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases).
+
+## Step 2: Get Your Sentry OTLP Credentials
+
+You'll need your Sentry OTLP endpoint and authentication header. These can be found in your [Sentry Project Settings](https://sentry.io/settings/projects/) under **Client Keys (DSN)** > **OpenTelemetry (OTLP)**.
+
+### OTEL Endpoint
+
+```bash
+___OTLP_URL___
+```
+
+### Authentication Header
+
+```
+x-sentry-auth: sentry sentry_key=___PUBLIC_KEY___
+```
+
+## Step 3: Configure the Collector
+
+Create a configuration file with the Kafka Receiver and the OTLP HTTP exporter configured to send telemetry to Sentry.
+
+For additional configuration options, see the [Kafka Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/kafkareceiver).
+
+### Configuration
+
+This configuration consumes both logs and traces from Kafka and forwards them to Sentry:
+
+```yaml {filename:config.yaml}
+receivers:
+  kafka:
+    brokers:
+      - localhost:9092
+    logs:
+      topic: otlp_logs
+      encoding: otlp_proto
+    traces:
+      topic: otlp_spans
+      encoding: otlp_proto
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    endpoint: ___OTLP_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - kafka
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+    traces:
+      receivers:
+        - kafka
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+### Consuming from Multiple Topics with Regex
+
+You can consume from multiple topics using regex patterns:
+
+```yaml {filename:config.yaml}
+receivers:
+  kafka:
+    brokers:
+      - localhost:9092
+    logs:
+      topic: "^logs-.*"
+      exclude_topic: "^logs-(test|dev)$"
+      encoding: otlp_proto
+    traces:
+      topic: "^traces-.*"
+      encoding: otlp_proto
+
+processors:
+  batch:
+
+exporters:
+  otlphttp/sentry:
+    endpoint: ___OTLP_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - kafka
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+    traces:
+      receivers:
+        - kafka
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+## Trace Propagation
+
+When traces are published to Kafka using the [Kafka Exporter](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/kafkaexporter) with `include_metadata_keys` configured, the Kafka Receiver automatically propagates Kafka message headers as request metadata throughout the pipeline. This preserves trace context information, allowing you to maintain distributed trace continuity across services that communicate via Kafka.
+
+To extract specific headers and attach them as resource attributes, use the `header_extraction` configuration:
+
+```yaml
+receivers:
+  kafka:
+    brokers:
+      - localhost:9092
+    traces:
+      topic: otlp_spans
+      encoding: otlp_proto
+    header_extraction:
+      extract_headers: true
+      headers: ["traceparent", "tracestate"]
+```
+
+## Supported Encodings
+
+The Kafka Receiver supports various encodings for different signal types:
+
+**All signals (logs, traces):**
+
+- `otlp_proto` (default): OTLP Protobuf format
+- `otlp_json`: OTLP JSON format
+
+**Traces only:**
+
+- `jaeger_proto`: Jaeger Protobuf format
+- `jaeger_json`: Jaeger JSON format
+- `zipkin_proto`: Zipkin Protobuf format
+- `zipkin_json`: Zipkin JSON format
+
+**Logs only:**
+
+- `raw`: Raw bytes as log body
+- `text`: Text decoded as log body
+- `json`: JSON decoded as log body
+
+## Troubleshooting
+
+- Verify the Kafka broker addresses are correct and accessible
+- Ensure the topic names match the topics where telemetry data is being published
+- Check that the encoding matches the format of data in your Kafka topics
+- If using authentication, verify your credentials and SASL mechanism
+- Confirm the consumer group has permissions to read from the configured topics
+
+## Additional Resources
+
+- [Kafka Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/kafkareceiver)
+- [Sentry OpenTelemetry Collector Configuration](/product/drains/integration/opentelemetry-collector/)
+- [Sentry Logs](/product/explore/logs/)
diff --git a/docs/product/drains/otlp-guides/nginx.mdx b/docs/product/drains/otlp-guides/nginx.mdx
new file mode 100644
index 0000000000000..b1e37759b26ac
--- /dev/null
+++ b/docs/product/drains/otlp-guides/nginx.mdx
@@ -0,0 +1,290 @@
+---
+title: Forwarding Nginx Logs to Sentry via the OpenTelemetry Protocol (OTLP)
+sidebar_order: 200
+description: "Learn how to forward Nginx access logs to Sentry via the OpenTelemetry Protocol (OTLP)."
+keywords: ["otlp", "otel", "opentelemetry", "nginx", "logs", "web server"]
+---
+
+This guide shows you how to collect Nginx access logs and forward them to Sentry using the OpenTelemetry Collector with the [File Log Receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/filelogreceiver).
+
+## Prerequisites
+
+Before you begin, ensure you have:
+
+- Nginx installed and running
+- Access to Nginx log files (typically at `/var/log/nginx/`)
+- A Sentry project to send data to
+
+## Step 1: Install the OpenTelemetry Collector
+
+The File Log Receiver is included in the [OpenTelemetry Collector Contrib](https://github.com/open-telemetry/opentelemetry-collector-releases/tree/main/distributions/otelcol-contrib) distribution. You'll need to download and install this version, as the standard `otelcol` binary does not include the File Log Receiver.
+
+Download the latest `otelcol-contrib` binary from the [OpenTelemetry Collector releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases).
+
+## Step 2: Get Your Sentry OTLP Credentials
+
+You'll need your Sentry OTLP endpoint and authentication header. These can be found in your [Sentry Project Settings](https://sentry.io/settings/projects/) under **Client Keys (DSN)** > **OpenTelemetry (OTLP)**.
+
+### Logs Endpoint
+
+```bash
+___OTLP_LOGS_URL___
+```
+
+### Authentication Header
+
+```
+x-sentry-auth: sentry sentry_key=___PUBLIC_KEY___
+```
+
+## Step 3: Configure Nginx Logging
+
+Nginx logs are stored by default at `/var/log/nginx/access.log`. For better observability, configure Nginx to output structured JSON logs with trace context fields. This allows your Nginx logs to be correlated with distributed traces in Sentry.
+
+### JSON Logging with Trace Context (Recommended)
+
+To correlate Nginx logs with traces, you need to include trace context fields in your log format. This requires the [NGINX OpenTelemetry module](https://github.com/open-telemetry/opentelemetry-cpp-contrib/tree/main/instrumentation/nginx) to be installed, which provides the `$otel_trace_id`, `$otel_span_id`, and `$otel_trace_flags` variables.
+
+Add the following to your Nginx configuration (typically `/etc/nginx/nginx.conf`):
+
+```nginx {filename:nginx.conf}
+load_module modules/ngx_otel_module.so;
+
+http {
+    # Enable OpenTelemetry tracing
+    otel_exporter {
+        endpoint localhost:4317;
+    }
+    otel_trace on;
+
+    log_format json_combined escape=json
+      '{'
+        '"time_local":"$time_local",'
+        '"remote_addr":"$remote_addr",'
+        '"remote_user":"$remote_user",'
+        '"request":"$request",'
+        '"status":$status,'
+        '"body_bytes_sent":$body_bytes_sent,'
+        '"http_referer":"$http_referer",'
+        '"http_user_agent":"$http_user_agent",'
+        '"request_time":$request_time,'
+        '"trace_id":"$otel_trace_id",'
+        '"span_id":"$otel_span_id",'
+        '"trace_flags":"$otel_trace_flags"'
+      '}';
+
+    access_log /var/log/nginx/access.log json_combined;
+
+    # ... rest of your configuration
+}
+```
+
+The trace context fields enable Sentry to link your Nginx access logs directly to the corresponding traces, giving you full visibility into request flows.
+
+### Basic JSON Logging (Without Trace Context)
+
+If you don't have the OpenTelemetry module installed, you can still use structured JSON logging:
+
+```nginx {filename:nginx.conf}
+http {
+    log_format json_combined escape=json
+      '{'
+        '"time_local":"$time_local",'
+        '"remote_addr":"$remote_addr",'
+        '"remote_user":"$remote_user",'
+        '"request":"$request",'
+        '"status":$status,'
+        '"body_bytes_sent":$body_bytes_sent,'
+        '"http_referer":"$http_referer",'
+        '"http_user_agent":"$http_user_agent",'
+        '"request_time":$request_time'
+      '}';
+
+    access_log /var/log/nginx/access.log json_combined;
+
+    # ... rest of your configuration
+}
+```
+
+After modifying the configuration, validate and reload Nginx:
+
+```bash
+sudo nginx -t
+sudo systemctl reload nginx
+```
+
+## Step 4: Configure the Collector
+
+Create a configuration file with the File Log Receiver and the OTLP HTTP exporter configured to send logs to Sentry.
+
+For additional configuration options, see the [File Log Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/filelogreceiver).
+
+### Configuration with Trace Context (Recommended)
+
+If you configured Nginx with the OpenTelemetry module and JSON logging with trace context fields, use this configuration to parse the logs and extract trace correlation:
+
+```yaml {filename:config.yaml}
+receivers:
+  filelog:
+    include:
+      - /var/log/nginx/access.log
+    attributes:
+      service.name: nginx
+    operators:
+      - type: json_parser
+        timestamp:
+          parse_from: attributes.time_local
+          layout: "%d/%b/%Y:%H:%M:%S %z"
+      - type: trace_parser
+        trace_id:
+          parse_from: attributes.trace_id
+        span_id:
+          parse_from: attributes.span_id
+        trace_flags:
+          parse_from: attributes.trace_flags
+
+  filelog/error:
+    include:
+      - /var/log/nginx/error.log
+    attributes:
+      service.name: nginx
+      log.type: error
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - filelog
+        - filelog/error
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+The `trace_parser` operator extracts the trace ID, span ID, and trace flags from the parsed JSON attributes and sets them on the log record. This enables Sentry to correlate these logs with the corresponding traces.
+
+### Basic Configuration
+
+This configuration collects Nginx access and error logs:
+
+```yaml {filename:config.yaml}
+receivers:
+  filelog:
+    include:
+      - /var/log/nginx/access.log
+      - /var/log/nginx/error.log
+    attributes:
+      service.name: nginx
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - filelog
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+### Configuration with Multiple Nginx Instances
+
+If you have multiple Nginx instances or virtual hosts with separate log files:
+
+```yaml {filename:config.yaml}
+receivers:
+  filelog/site1:
+    include:
+      - /var/log/nginx/site1.access.log
+    attributes:
+      service.name: nginx
+      site: site1
+
+  filelog/site2:
+    include:
+      - /var/log/nginx/site2.access.log
+    attributes:
+      service.name: nginx
+      site: site2
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - filelog/site1
+        - filelog/site2
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+## Step 5: Run the Collector
+
+Start the OpenTelemetry Collector with your configuration:
+
+```bash
+./otelcol-contrib --config config.yaml
+```
+
+To run in the background:
+
+```bash
+./otelcol-contrib --config config.yaml &> otelcol-output.log &
+```
+
+## Troubleshooting
+
+- Verify the OpenTelemetry Collector has read permissions for the Nginx log files
+- Ensure the log file paths in the configuration match your Nginx setup
+- Check that Nginx is actively writing to the configured log files
+- If using JSON parsing, verify your Nginx log format matches the parser configuration
+
+## Additional Resources
+
+- [File Log Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/filelogreceiver)
+- [Sentry OpenTelemetry Collector Configuration](/product/drains/integration/opentelemetry-collector/)
+- [Sentry Logs](/product/explore/logs/)
diff --git a/docs/product/drains/otlp-guides/syslog.mdx b/docs/product/drains/otlp-guides/syslog.mdx
new file mode 100644
index 0000000000000..8b449fef8ddc7
--- /dev/null
+++ b/docs/product/drains/otlp-guides/syslog.mdx
@@ -0,0 +1,165 @@
+---
+title: Forwarding Syslog Messages to Sentry via the OpenTelemetry Protocol (OTLP)
+sidebar_order: 300
+description: "Learn how to forward syslog messages to Sentry via the OpenTelemetry Protocol (OTLP)."
+keywords: ["otlp", "otel", "opentelemetry", "syslog"]
+---
+
+This guide shows you how to collect syslog messages and forward them to Sentry using the OpenTelemetry Collector with the [Syslog Receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/syslogreceiver).
+
+## Prerequisites
+
+Before you begin, ensure you have:
+
+- Network access to receive syslog messages (TCP or UDP)
+- A Sentry project to send data to
+
+## Step 1: Install the OpenTelemetry Collector
+
+The Syslog Receiver is included in the [OpenTelemetry Collector Contrib](https://github.com/open-telemetry/opentelemetry-collector-releases/tree/main/distributions/otelcol-contrib) distribution. You'll need to download and install this version, as the standard `otelcol` binary does not include the Syslog Receiver.
+
+Download the latest `otelcol-contrib` binary from the [OpenTelemetry Collector releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases).
+
+## Step 2: Get Your Sentry OTLP Credentials
+
+You'll need your Sentry OTLP endpoint and authentication header. These can be found in your [Sentry Project Settings](https://sentry.io/settings/projects/) under **Client Keys (DSN)** > **OpenTelemetry (OTLP)**.
+
+### Logs Endpoint
+
+```bash
+___OTLP_LOGS_URL___
+```
+
+### Authentication Header
+
+```
+x-sentry-auth: sentry sentry_key=___PUBLIC_KEY___
+```
+
+## Step 3: Configure the Collector
+
+Create a configuration file with the Syslog Receiver and the OTLP HTTP exporter configured to send logs to Sentry.
+
+For additional configuration options like TLS, async processing, or custom attributes, see the [Syslog Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/syslogreceiver).
+
+### TCP Configuration (RFC 5424)
+
+This configuration receives syslog messages over TCP using the RFC 5424 format:
+
+```yaml {filename:config.yaml}
+receivers:
+  syslog:
+    tcp:
+      listen_address: "0.0.0.0:514"
+    protocol: rfc5424
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - syslog
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+### UDP Configuration (RFC 3164)
+
+This configuration receives syslog messages over UDP using the older RFC 3164 (BSD syslog) format:
+
+```yaml {filename:config.yaml}
+receivers:
+  syslog:
+    udp:
+      listen_address: "0.0.0.0:514"
+    protocol: rfc3164
+    location: UTC
+
+processors:
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - syslog
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+## Configuring Syslog Sources
+
+After setting up the collector, configure your systems to send syslog messages to it.
+
+### Linux (rsyslog)
+
+Add the following to `/etc/rsyslog.conf` or create a file in `/etc/rsyslog.d/`:
+
+```bash {filename:/etc/rsyslog.d/50-otel.conf}
+# For TCP (RFC 5424)
+*.* @@otel-collector-host:514
+
+# For UDP (RFC 3164)
+*.* @otel-collector-host:514
+```
+
+Then restart rsyslog:
+
+```bash
+sudo systemctl restart rsyslog
+```
+
+### Linux (syslog-ng)
+
+Add to your syslog-ng configuration:
+
+```bash
+destination d_otel {
+    network("otel-collector-host" port(514) transport("tcp"));
+};
+
+log {
+    source(s_sys);
+    destination(d_otel);
+};
+```
+
+## Troubleshooting
+
+- Verify the syslog source is sending to the correct host and port
+- Ensure firewall rules allow inbound traffic on the configured port
+- Confirm the protocol setting matches your syslog source (RFC 3164 vs RFC 5424)
+
+## Additional Resources
+
+- [Syslog Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/syslogreceiver)
+- [Sentry OpenTelemetry Collector Configuration](/product/drains/integration/opentelemetry-collector/)
+- [Sentry Logs](/product/explore/logs/)
diff --git a/docs/product/drains/otlp-guides/windows-events.mdx b/docs/product/drains/otlp-guides/windows-events.mdx
new file mode 100644
index 0000000000000..c9570c13d6b75
--- /dev/null
+++ b/docs/product/drains/otlp-guides/windows-events.mdx
@@ -0,0 +1,239 @@
+---
+title: Forwarding Windows Event Logs to Sentry via the OpenTelemetry Protocol (OTLP)
+sidebar_order: 400
+description: "Learn how to forward Windows Event Logs to Sentry via the OpenTelemetry Protocol (OTLP)."
+keywords: ["otlp", "otel", "opentelemetry", "windows", "event", "logs"]
+---
+
+This guide shows you how to collect Windows Event Logs and forward them to Sentry using the OpenTelemetry Collector with the [Windows Event Log Receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/windowseventlogreceiver).
+
+## Prerequisites
+
+Before you begin, ensure you have:
+
+- A Windows Server or Windows machine (Windows Vista or later)
+- A Microsoft user account with permissions to access the Windows Event Log
+- A Microsoft user account with permissions to create Services (for running the collector as a service)
+- A Sentry project to send data to
+
+## Step 1: Install the OpenTelemetry Collector
+
+The Windows Event Log Receiver is included in the [OpenTelemetry Collector Contrib](https://github.com/open-telemetry/opentelemetry-collector-releases/tree/main/distributions/otelcol-contrib) distribution. You'll need to download and install this version, as the standard `otelcol` binary does not include the Windows Event Log Receiver.
+
+### Binary Installation
+
+1. Download the latest `otelcol-contrib` binary from the [OpenTelemetry Collector releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases).
+
+2. Extract the binary to a directory, for example `C:\otel-collector\`.
+
+3. Create the service using the following command in an elevated Command Prompt or PowerShell:
+
+```shell
+sc.exe create otelcol-contrib displayname=otelcol-contrib start=delayed-auto binPath="C:\otel-collector\otelcol-contrib.exe --config C:\otel-collector\config.yaml"
+```
+
+### MSI Installation
+
+Alternatively, you can install the OpenTelemetry Collector using the MSI installer:
+
+1. Download the latest MSI installer from the [OpenTelemetry Collector releases page](https://github.com/open-telemetry/opentelemetry-collector-releases/releases).
+
+2. Run the installer on your Windows Server.
+
+3. The service named `otelcol-contrib` will be created and started automatically upon completion.
+
+## Step 2: Get Your Sentry OTLP Credentials
+
+You'll need your Sentry OTLP endpoint and authentication header. These can be found in your [Sentry Project Settings](https://sentry.io/settings/projects/) under **Client Keys (DSN)** > **OpenTelemetry (OTLP)**.
+
+### Logs Endpoint
+
+```bash
+___OTLP_LOGS_URL___
+```
+
+### Authentication Header
+
+```
+x-sentry-auth: sentry sentry_key=___PUBLIC_KEY___
+```
+
+## Step 3: Configure the Collector
+
+Create a configuration file at `C:\otel-collector\config.yaml` with the Windows Event Log Receiver and the OTLP HTTP exporter configured to send logs to Sentry.
+
+### Basic Configuration
+
+This configuration collects logs from the three main Windows Event Log channels: Application, System, and Security.
+
+```yaml {filename:config.yaml}
+receivers:
+  windowseventlog/application:
+    channel: application
+  windowseventlog/system:
+    channel: system
+  windowseventlog/security:
+    channel: security
+
+processors:
+  resourcedetection:
+    detectors: [system]
+    system:
+      hostname_sources: ["os"]
+  batch:
+    send_batch_size: 1024
+    send_batch_max_size: 2048
+    timeout: "1s"
+
+exporters:
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - windowseventlog/application
+        - windowseventlog/system
+        - windowseventlog/security
+      processors:
+        - resourcedetection
+        - batch
+      exporters:
+        - otlphttp/sentry
+```
+
+### Configuration Options
+
+The Windows Event Log Receiver supports several configuration options:
+
+| Option              | Default    | Description                                                                                     |
+| ------------------- | ---------- | ----------------------------------------------------------------------------------------------- |
+| `channel`           | _required_ | The Windows Event Log channel to monitor (e.g., `application`, `system`, `security`)            |
+| `start_at`          | `end`      | Where to start reading logs on first startup (`beginning` or `end`)                             |
+| `poll_interval`     | `1s`       | Interval at which the channel is checked for new log entries                                    |
+| `max_reads`         | `100`      | Maximum number of records read into memory before starting a new batch                          |
+| `raw`               | `false`    | If `true`, the log body contains the original XML string instead of a structured representation |
+| `exclude_providers` | `[]`       | List of event log providers to exclude from processing                                          |
+
+### Filtering Events with XML Queries
+
+You can use XML queries to filter specific events. This example only forwards logs from specific providers:
+
+```yaml {filename:config.yaml}
+receivers:
+  windowseventlog/filtered:
+    query: |
+      <QueryList>
+        <Query Id="0">
+          <Select Path="Application">*[System[Provider[@Name='MyApp']]]</Select>
+          <Select Path="System">*[System[Level&lt;=2]]</Select>
+        </Query>
+      </QueryList>
+```
+
+The query above collects:
+
+- All events from the `MyApp` provider in the Application channel
+- Events with severity level 2 (Error) or lower from the System channel
+
+For more information on XML query syntax, see [Microsoft's Query Schema documentation](https://learn.microsoft.com/en-us/windows/win32/wes/queryschema-schema).
+
+### Collecting from Remote Machines
+
+You can collect Windows Event Logs from remote machines by configuring the `remote` option:
+
+```yaml {filename:config.yaml}
+receivers:
+  windowseventlog/remote:
+    channel: application
+    remote:
+      server: "remote-server"
+      username: "user"
+      password: "password"
+      domain: "domain"
+```
+
+<Alert level="info" title="Remote Collection Requirements">
+
+For remote collection to work:
+
+- The remote computer must have the "Remote Event Log Management" Windows Firewall exception enabled.
+- The remote computer must be running Windows Vista or later.
+- You'll need a separate receiver configuration for local event log collection.
+
+</Alert>
+
+## Step 4: Start the Collector
+
+Once you've created your configuration file, configure the restart settings and start the service:
+
+```shell
+sc.exe failure otelcol-contrib reset= 86400 actions= restart/5000/restart/5000/restart/5000
+sc.exe start otelcol-contrib
+```
+
+## Troubleshooting
+
+If logs aren't appearing in Sentry, you can add a debug exporter to troubleshoot:
+
+1. Stop the service:
+
+```shell
+sc.exe stop otelcol-contrib
+```
+
+2. Create a debug configuration file (`config_debug.yaml`) with a debug exporter:
+
+```yaml {filename:config_debug.yaml}
+receivers:
+  windowseventlog/application:
+    channel: application
+
+processors:
+  batch:
+
+exporters:
+  debug:
+    verbosity: detailed
+  otlphttp/sentry:
+    logs_endpoint: ___OTLP_LOGS_URL___
+    headers:
+      x-sentry-auth: "sentry sentry_key=___PUBLIC_KEY___"
+    compression: gzip
+    encoding: proto
+
+service:
+  pipelines:
+    logs:
+      receivers:
+        - windowseventlog/application
+      processors:
+        - batch
+      exporters:
+        - otlphttp/sentry
+        - debug
+```
+
+3. Run the collector manually to see debug output:
+
+```shell
+C:\otel-collector\otelcol-contrib.exe --config C:\otel-collector\config_debug.yaml
+```
+
+4. Review the console output to verify events are being processed correctly.
+
+5. If events are processed but not reaching Sentry, check:
+   - Network connectivity to Sentry's ingestion endpoint
+   - Firewall rules allowing outbound HTTPS traffic
+   - The correctness of your Sentry credentials
+
+## Additional Resources
+
+- [Windows Event Log Receiver Documentation](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/windowseventlogreceiver)
+- [Sentry OpenTelemetry Collector Configuration](/product/drains/integration/opentelemetry-collector/)
+- [Sentry Logs](/product/explore/logs/)