Splunk Observability Cloud Documentation

https://github.com/splunk/public-o11y-docs
Admin
This repository contains deprecated documentation for Splunk Observability Cloud, now migrated to a...
Tokens:665,956
Snippets:10,447
Trust Score:9.4
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install SignalFx PHP Tracing Library

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/sfx/instrumentation/instrument-php-application.rst

Run the downloaded setup script to install the SignalFx tracing library. The --php-bin=all option automatically detects and configures all PHP installations. Omitting this option allows for interactive selection.

```shell
php signalfx-setup.php --php-bin=all
```

--------------------------------

### Extended vSphere Monitor Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/monitors-hosts/vsphere.rst

An example demonstrating extended configuration options for the vSphere monitor, including host, username, password, and exporter setup.

```yaml
receivers:
  smartagent/vsphere:
    type: vsphere
    host: hostname
    username: user
    password: pass
    insecureSkipVerify: true
exporters:
  signalfx:
    access_token: abc123
    realm: us2
service:
  pipelines:
    metrics:
      receivers:
        - smartagent/vsphere
      exporters:
        - signalfx
```

--------------------------------

### Start Tracing with Custom Configuration

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/python/instrumentation/python-manual-instrumentation.rst

This example shows how to start OpenTelemetry tracing with custom configurations such as service name, span exporter, access token, and resource attributes. It requires importing the start_otel function.

```python
from splunk_otel.tracing import start_tracing
from opentelemetry.sdk.trace.export import OTLPSpanExporter

start_tracing(
  service_name='<my-python-service>',
  span_exporter_factories=[OTLPSpanExporter]
  access_token='<access_token>',
  max_attr_length=12000,
  trace_response_header_enabled=True,
  resource_attributes={
   'service.version': '<your_version>',
   'deployment.environment': '<your_environment>',
  })
```

--------------------------------

### Verify Running Containers

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/logs-collector-splunk-tutorial/deploy-verify-environment.rst

This is an example of the expected output after successfully starting the log collection services with Docker Compose.

```bash
[+] Running 5/5
✔ Network docker-tutorial_default  Created                                                                                                               0.0s
✔ Container splunk                 Healthy                                                                                                              77.1s
✔ Container otelcollector          Started                                                                                                              77.2s
✔ Container logging2               Started                                                                                                              77.5s
✔ Container logging1               Started                                                                                                              77.5s
```

--------------------------------

### Create Meter Provider and Get Meter

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/python/instrumentation/python-manual-instrumentation.rst

Set up a MeterProvider with a metric reader and exporter, then retrieve a meter instance using its name to start creating custom metrics.

```python
meter := otel.Meter("ExampleService")

metric_reader = PeriodicExportingMetricReader(ConsoleMetricExporter())
provider = MeterProvider(metric_readers=[metric_reader])

metrics.set_meter_provider(provider)
meter = metrics.get_meter("my.meter.name")
```

--------------------------------

### Install Node.js Dependencies

Source: https://github.com/splunk/public-o11y-docs/blob/main/apm/apm-data-links/apm-datalinks-terraform/apm-create-data-links-terraform-batch.rst

Run this command in the Node.js script's directory to install all necessary packages. Ensure Node.js is installed and accessible in your PATH.

```none
npm install
```

--------------------------------

### Build and run the Docker Compose setup

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/otel-other/other-ingestion-collectd.rst

Execute this command to build the Docker images and start the services defined in your `docker-compose.yml` file. This command is used to initiate the collectd and OpenTelemetry Collector setup.

```bash
$> docker compose up --build
```

--------------------------------

### Kubernetes Distribution Examples

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/kubernetes-config.rst

Examples of Helm chart --set arguments for different Kubernetes distributions and cloud providers.

```bash
--set distribution=aks,cloudProvider=azure
```

```bash
--set distribution=eks,cloudProvider=aws
```

```bash
--set distribution=eks/fargate,gateway.enabled=true,cloudProvider=aws
```

```bash
--set distribution=gke,cloudProvider=gcp
```

```bash
--set distribution=gke/autopilot,cloudProvider=gcp
```

```bash
--set distribution=openshift
```

--------------------------------

### Install Kubernetes Tools with Homebrew

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/collector-configuration-tutorial-k8s/collector-config-tutorial-start.rst

Install Minikube, Helm, and Podman using Homebrew in your terminal session.

```bash
brew install minikube helm podman
```

--------------------------------

### Configure Java Agent with System Properties

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/java/version1x/java-1x-otel-configuration.rst

This example shows how to configure the Java agent using system properties when starting a Java application. System properties override environment variables.

```shell
java -javaagent:./splunk-otel-javaagent.jar \
         -Dotel.service.name=<my-java-app> \
         -jar <myapp>.jar
```

--------------------------------

### Install a Private Runner on Docker

Source: https://github.com/splunk/public-o11y-docs/blob/main/synthetics/test-config/private-locations.rst

Use this command to start a new private runner container. Ensure you replace YOUR_TOKEN_HERE with your actual runner token.

```shell
docker run --cap-add NET_ADMIN \
  -e "RUNNER_TOKEN=YOUR_TOKEN_HERE" \
  quay.io/signalfx/splunk-synthetics-runner:latest
```

--------------------------------

### Start Jetty with Java agent

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/java/instrumentation/java-servers-instructions.rst

Use this command to start Jetty with the Java agent enabled.

```shell
java -javaagent:/path/to/splunk-otel-javaagent.jar -jar start.jar
```

--------------------------------

### Example Discovery Output for PostgreSQL

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-third-party.rst

This example shows the output when discovery mode cannot authenticate to a PostgreSQL server, providing guidance on how to set credentials.

```text
$ Discovering for next 10s...
Partially discovered "smartagent/postgresql" using "docker_observer"
endpoint "5c9c80ba4319395c26255b6374f048ca973d3618fdd4b92a9ed601c7dddbff6a:5432":
Please ensure your user credentials are correctly specified with
`--set splunk.discovery.receivers.smartagent/postgresql.config.params::username="<username>"`
and `--set splunk.discovery.receivers.smartagent/postgresql.config.params::password="<password>"`
or `SPLUNK_DISCOVERY_RECEIVERS_smartagent_x2f_postgresql_CONFIG_params_x3a__x3a_username="<username>"`
and `SPLUNK_DISCOVERY_RECEIVERS_smartagent_x2f_postgresql_CONFIG_params_x3a__x3a_password="<password>"`
environment variables.
```

--------------------------------

### Install Private Runner with Podman

Source: https://github.com/splunk/public-o11y-docs/blob/main/synthetics/test-config/private-locations.rst

Starts a private runner container using Podman. Requires NET_ADMIN capability and the RUNNER_TOKEN environment variable.

```shell
podman run --cap-add NET_ADMIN -e "RUNNER_TOKEN=YOUR_TOKEN_HERE" \
 quay.io/signalfx/splunk-synthetics-runner:latest
```

--------------------------------

### Server-Timing Header Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/rum/android/manual-rum-android-instrumentation.rst

Provides an example of a manually created Server-Timing header with the traceparent field.

```shell
Server-Timing: traceparent;desc="00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01"
```

--------------------------------

### Verify Tool Installations

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/collector-configuration-tutorial-k8s/collector-config-tutorial-start.rst

Check that Minikube, Podman, and Helm have been successfully installed by running their respective version commands.

```bash
minikube version
```

```bash
podman -v
```

```bash
helm version
```

--------------------------------

### Install Express Framework

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/troubleshooting/common-nodejs-troubleshooting.rst

Install the express framework to enable OpenTelemetry instrumentation. Ensure the package is in the node_modules folder.

```shell
npm install express
```

--------------------------------

### Default Smart Agent Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/smart-agent/smart-agent-migration-process.rst

This is an example of a default Smart Agent configuration file, showing various settings and paths.

```yaml
signalFxAccessToken: {"#from": "env:SIGNALFX_ACCESS_TOKEN"}
ingestUrl: https://ingest.us1.signalfx.com
apiUrl: https://api.us1.signalfx.com

bundleDir: /opt/my-smart-agent-bundle

procPath: /my_custom_proc
etcPath: /my_custom_etc
varPath: /my_custom_var
runPath: /my_custom_run
sysPath: /my_custom_sys

observers:
   - type: k8s-api

collectd:
   readThreads: 10
   writeQueueLimitHigh: 1000000
   writeQueueLimitLow: 600000
configDir: "/tmp/signalfx-agent/collectd"
```

--------------------------------

### Download and Install Splunk OpenTelemetry .NET (Linux)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/otel-dotnet/instrumentation/instrument-dotnet-application.rst

Download the installation script for the Splunk Distribution of OpenTelemetry .NET from GitHub and then execute the script to install the distribution on Linux systems.

```shell
curl -sSfL https://github.com/signalfx/splunk-otel-dotnet/releases/latest/download/splunk-otel-dotnet-install.sh -O
      # Install the distribution
      sh ./splunk-otel-dotnet-install.sh
```

--------------------------------

### Download SignalFx PHP Tracing Setup Script

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/sfx/instrumentation/instrument-php-application.rst

Use this command to download the latest version of the SignalFx setup script for PHP instrumentation.

```shell
curl -LO  https://github.com/signalfx/signalfx-php-tracing/releases/latest/download/signalfx-setup.php
```

--------------------------------

### Install Collector with Systemd, Profiling, and Metrics

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

Enable AlwaysOn Profiling and metrics when installing with systemd instrumentation by including the relevant flags.

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh && \
                            sudo sh /tmp/splunk-otel-collector.sh --with-systemd-instrumentation --deployment-environment prod \
                            --realm <SPLUNK_REALM> -- <SPLUNK_ACCESS_TOKEN> \
                            --enable-profiler --enable-profiler-memory --enable-metrics
```

--------------------------------

### SignalFx Tracing Initialization (Example)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/troubleshooting/migrate-signalfx-nodejs-agent-to-otel.rst

This is an example of how the SignalFx tracing library was initialized. It is provided for comparison when migrating to OpenTelemetry.

```javascript
const tracer = require('signalfx-tracing').init({
 // your options here
})
```

--------------------------------

### Install Collector with Java Zero-Code Instrumentation (System-wide)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

Installs the zero-code instrumentation package for Java and activates it system-wide using the installer script. Replace placeholders with your Splunk Observability Cloud realm and access token.

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh && \
                            sudo sh /tmp/splunk-otel-collector.sh --with-instrumentation --realm <SPLUNK_REALM> -- <SPLUNK_ACCESS_TOKEN>
```

--------------------------------

### Install Collector with Systemd and Deployment Environment

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

Configure the deployment.environment resource attribute during installation by using the --deployment-environment option with systemd instrumentation.

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh && \
                            sudo sh /tmp/splunk-otel-collector.sh --with-systemd-instrumentation --deployment-environment prod \
                            --realm <SPLUNK_REALM> -- <SPLUNK_ACCESS_TOKEN>
```

--------------------------------

### Advanced GenericJMX Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/monitors-languages/genericjmx.rst

This example demonstrates advanced configuration for the GenericJMX monitor, including specific host, port, and MBean definitions for threading metrics.

```yaml
receivers:
  smartagent/genericjmx:
    type: collectd/genericjmx
    host: my-java-app
    port: 7099
    mBeanDefinitions:
      threading:
        objectName: java.lang:type=Threading
        values:
          - type: gauge
            table: false
            instancePrefix: jvm.threads.count
            attribute: ThreadCount
```

--------------------------------

### Start Alertmanager

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/prometheus-integration.rst

Command to start the Alertmanager service using its configuration file.

```shell
./alertmanager -config.file=alertmanager.yml
```

--------------------------------

### Install Collector with Profiling and Metrics

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

Activate AlwaysOn Profiling for CPU and memory, along with metrics, by adding specific flags to the installer script.

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh && \
                            sudo sh /tmp/splunk-otel-collector.sh --with-instrumentation --deployment-environment prod \
                            --realm <SPLUNK_REALM> -- <SPLUNK_ACCESS_TOKEN> \
                            --enable-profiler --enable-profiler-memory --enable-metrics
```

--------------------------------

### Chrony Receiver Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/components/chrony-receiver.rst

This example shows advanced configuration options including collection_interval and specific metrics to enable.

```yaml
receivers:
  chrony:
    endpoint: unix:///var/run/chrony/chronyd.sock
    timeout: 10s
    collection_interval: 30s
    metrics:
      ntp.skew:
        enabled: true
      ntp.stratum:
        enabled: true
```

--------------------------------

### Install OpenTelemetry Packages for Go Lambda

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/serverless/aws/otel-lambda-layer/instrumentation/go-lambdas.rst

Run these commands to install the otellambda package and the Splunk OTel Go distribution.

```bash
go get -u go.opentelemetry.io/contrib/instrumentation/github.com/aws/aws-lambda-go/otellambda
go get -u github.com/signalfx/splunk-otel-go/distro
```

--------------------------------

### Install CheckMK Plugin (deb)

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/check_mk-integration.rst

Install the downloaded CheckMK plugin package using dpkg or apt.

```bash
dpkg -i <path_to_file>
```

```bash
sudo apt install <path_to_file>
```

--------------------------------

### Programmatic Instrumentation with Metrics and Profiling

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/instrumentation/instrument-nodejs-application.rst

Use the start() function to activate runtime metrics and memory profiling by passing configuration settings.

```javascript
start({
   serviceName: 'my-node-service',
   metrics: { runtimeMetricsEnabled: true },
   profiling: { memoryProfilingEnabled: true }
});
```

--------------------------------

### Start Collector Executable Manually

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-windows/install-windows.rst

If the Collector fails to start automatically, use this command to start the executable manually. This command assumes the default installation path.

```PowerShell
& 'C:\Program Files\Splunk\OpenTelemetry Collector\otelcol.exe' --config 'C:\ProgramData\Splunk\OpenTelemetry Collector\agent_config.yaml'
```

--------------------------------

### Start Splunk OpenTelemetry Collector Service

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-windows/install-windows-msi.rst

Use this command to start the `splunk-otel-collector` service after installation. This can be done by rebooting the system or running this command in PowerShell.

```PowerShell
Start-Service splunk-otel-collector
```

--------------------------------

### Install CheckMK Plugin (rpm)

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/check_mk-integration.rst

Install the downloaded CheckMK plugin package using rpm.

```bash
rpm -i <path_to_file>
```

--------------------------------

### StatusCast Webhook Payload Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/statuscast-integration-guide.rst

This is an example of the JSON payload that can be sent to StatusCast to create or update incidents. Customize the values to match your monitoring setup.

```text
{

   monitorName: "${{ALERT.monitor_name}}",
   state: "${{ALERT.entity_state}}"

}
```

--------------------------------

### Detailed OTLP/HTTP Exporter Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/components/otlphttp-exporter.rst

A comprehensive configuration example demonstrating various settings including endpoints, headers, timeouts, buffer sizes, sending queue, retry mechanisms, and compression.

```yaml
endpoint: "https://1.2.3.4:1234"
traces_endpoint: https://ingest.<realm>.signalfx.com/v2/trace/otlp
metrics_endpoint: https://ingest.<realm>.signalfx.com/v2/datapoint/otlp
headers:
  X-SF-Token: <access_token>
timeout: 10s
read_buffer_size: 123
write_buffer_size: 345
sending_queue:
  enabled: true
  num_consumers: 2
  queue_size: 10
retry_on_failure:
  enabled: true
  initial_interval: 10s
  randomization_factor: 0.7
  multiplier: 1.3
  max_interval: 60s
  max_elapsed_time: 10m
compression: gzip
```

--------------------------------

### Create MeterProvider entry point in PHP

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/php-manual-instrumentation.rst

Obtain the MeterProvider instance, which is the entry point for creating instruments and metrics.

```php
$meterProvider = Globals::meterProvider();
```

--------------------------------

### Start Docker Compose Services

Source: https://github.com/splunk/public-o11y-docs/blob/main/synthetics/test-config/private-locations.rst

Command to start all services defined in your docker-compose.yml file.

```shell
docker-compose up
```

--------------------------------

### Start Minikube Kubernetes Cluster

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/collector-configuration-tutorial-k8s/collector-config-tutorial-start.rst

Use this command to initiate a local Kubernetes cluster with Minikube. This is the first step for the tutorial.

```bash
minikube start
```

--------------------------------

### Install OpenTelemetry Collector with Custom Resources

Source: https://github.com/splunk/public-o11y-docs/blob/main/infrastructure/network-explorer/network-explorer-setup.rst

Install the Splunk OpenTelemetry Collector using Helm, specifying custom resource limits for CPU and memory during the installation process. This example sets CPU to 500m and memory to 1Gi.

```bash
helm --namespace=<NAMESPACE> install my-splunk-otel-collector --set="splunkObservability.realm=<REALM>,splunkObservability.accessToken=<ACCESS_TOKEN>,clusterName=<CLUSTER_NAME>,agent.enabled=false,clusterReceiver.enabled=false,gateway.replicaCount=1,gateway.resources.limits.cpu=500m,gateway.resources.limits.memory=1Gi" splunk-otel-collector-chart/splunk-otel-collector
```

--------------------------------

### Start Prometheus with Alertmanager URL

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/prometheus-integration.rst

Command to start the Prometheus server, specifying its configuration file and the Alertmanager URL.

```shell
./prometheus -config.file=prometheus.yml -alertmanager.url=http://localhost:9093
```

--------------------------------

### Initialize PHP Instrumentation in Docker

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/sfx/instrumentation/instrument-php-application.rst

Use these commands in a startup script to download, initialize, and configure the PHP tracing agent for Docker deployments. Ensure you replace placeholders like <realm>, <access_token>, and <service-name>.

```shell
curl -LO https://github.com/signalfx/signalfx-php-tracing/releases/latest/download/signalfx-setup.php
php signalfx-setup.php --php-bin=all
php signalfx-setup.php --update-config --signalfx.endpoint_url=https://ingest.<realm>.signalfx.com/v2/trace/signalfxv1
php signalfx-setup.php --update-config --signalfx.access_token=<access_token>
php signalfx-setup.php --update-config --signalfx.service_name=<service-name>
```

--------------------------------

### Example of formatted log output

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/ruby/distro/instrumentation/connect-traces-logs.rst

This is an example of how a log line will appear after applying the formatter to include trace and service metadata.

```text
service.name=basic-service trace_id=789b159aaee2b389a8771b2588278bcf span_id=6d26eba14a81f3fa
```

--------------------------------

### Ansible Playbook to Install Collector

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/deployments-linux-ansible.rst

Example Ansible playbook demonstrating how to use the `signalfx.splunk_otel_collector.collector` role to install the OpenTelemetry Collector. Requires root access and configuration of Splunk access token and realm.

```yaml
- name: Install the Splunk Distribution of OpenTelemetry Collector
  hosts: all
  become: yes
  tasks:
    - name: "Include splunk_otel_collector"
      include_role:
        name: "signalfx.splunk_otel_collector.collector"
      vars:
        splunk_access_token: YOUR_ACCESS_TOKEN
        splunk_realm: SPLUNK_REALM

```

--------------------------------

### Install Required PHP Instrumentations with Composer

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/instrument-php-application.rst

Install necessary OpenTelemetry instrumentations and adapters using Composer. This includes the OTLP exporter and a Guzzle adapter.

```bash
php composer.phar install open-telemetry/exporter-otlp:^1.0.3
php composer.phar install php-http/guzzle7-adapter:^1.0
```

--------------------------------

### Start PHP Application with Supervisor

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/sfx/instrumentation/instrument-php-application.rst

This command starts your PHP application using supervisorctl after the instrumentation has been set up in a Docker environment.

```shell
supervisor start my-php-app
```

--------------------------------

### Install Library/Framework for Node.js

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/version-2x/troubleshooting/common-nodejs-troubleshooting.rst

Install the required library or framework using npm to add it to the node_modules folder, making it available for the require method.

```shell
# Install the library or framework and add it to node_modules
npm install express
```

--------------------------------

### 404 Resource Error Span Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/rum/rum-identify-span-problems.rst

This example span illustrates a 404 error for an HTTP GET request, which can indicate a resource error or a backend issue. It shows the operation and relevant span details.

```text
Span ID                      c85a362c4668
Operation                    HTTP GET
```

--------------------------------

### Install Collector with Custom Parameters

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/install-k8s.rst

Install the collector and configure parameters like Splunk realm, access token, cluster name, distribution, and cloud provider using --set arguments. Ensure you replace placeholder values.

```bash
helm repo add splunk-otel-collector-chart https://signalfx.github.io/splunk-otel-collector-chart
helm install my-splunk-otel-collector --set="splunkRealm=us0,splunkAccessToken=xxxxxx,clusterName=my-cluster" --set=distribution={value},cloudProvider={value} splunk-otel-collector-chart/splunk-otel-collector
```

--------------------------------

### Download and Install Splunk OpenTelemetry .NET

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/otel-dotnet/instrumentation/instrument-dotnet-application.rst

Use PowerShell to download and import the OpenTelemetry .NET module, then install the Splunk distribution.

```powershell
# Download and import the PowerShell module
$module_url = "https://github.com/signalfx/splunk-otel-dotnet/releases/latest/download/Splunk.OTel.DotNet.psm1"
$download_path = Join-Path $env:temp "Splunk.OTel.DotNet.psm1"
Invoke-WebRequest -Uri $module_url -OutFile $download_path
Import-Module $download_path

# Install the Splunk distribution using the PowerShell module
Install-OpenTelemetryCore
```

--------------------------------

### Install Zabbix Integration (deb)

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/zabbix-integration.rst

Installs the Zabbix integration package using dpkg. Ensure you have root privileges.

```bash
wget
https://github.com/victorops/monitoring_tool_releases/releases/download/victorops-zabbix-0.18.3/victorops-zabbix_0.18.3-2_all.deb

sudo dpkg -i victorops-zabbix_0.18.3-2_all.deb
```

```bash
sudo ./install
```

--------------------------------

### Advanced Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/components/windowsperfcounters-receiver.rst

This example demonstrates advanced configuration options for the Windows Performance Counters receiver, including collection interval, initial delay, metric definitions, and specific counter configurations with attributes.

```yaml
windowsperfcounters:
  collection_interval: <duration>
  initial_delay: <duration>
  metrics:
    <metric name 1>:
      description: <description>
      unit: <unit type>
      gauge: null
    <metric name 2>:
      description: <description>
      unit: <unit type>
      sum: null
      aggregation: <cumulative or delta>
      monotonic: <true or false>
  perfcounters:
  - object: <object name>
    instances:
      - <instance name>
    counters:
      - name: <counter name>
        metric: <metric name>
        attributes:
        <key>: <value>
```

--------------------------------

### Install Zabbix Integration (rpm)

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/zabbix-integration.rst

Installs the Zabbix integration package using rpm. Ensure you have root privileges.

```shell
wget
https://github.com/victorops/monitoring_tool_releases/releases/download/victorops-zabbix-0.18.3/victorops-zabbix-0.18.3-2.noarch.rpm

sudo rpm -i victorops-zabbix-0.18.3-2.noarch.rpm
```

```shell
sudo ./install
```

--------------------------------

### Start Tracing with Default Configuration

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/python/instrumentation/python-manual-instrumentation.rst

Use this snippet to start OpenTelemetry tracing with default settings when the opentelemetry-instrument command cannot be used. Ensure you import the start_otel function.

```python
from splunk_otel.tracing import start_otel

start_otel()
```

--------------------------------

### Install CheckMK Plugin Scripts

Source: https://github.com/splunk/public-o11y-docs/blob/main/sp-oncall/spoc-integrations/check_mk-integration.rst

Run this script to create configuration file copies and symlinks for CheckMK integration.

```bash
/opt/victorops/nagios_plugin/omd_check_mk/install.sh <yoursitename>
```

--------------------------------

### Example Duration Metric

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/components/span-metrics-connector.rst

Demonstrates how duration is calculated from span start and end times and aggregated into histogram buckets, including status code.

```text
duration{service.name="shipping",span.name="get_shipping/{shippingId}",span.kind="SERVER",status.code="Ok"}
```

--------------------------------

### Install Collector to a Specific Namespace

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/install-k8s.rst

Deploy the Helm chart to a specific namespace by using the '-n' argument. This example deploys to the 'otel' namespace.

```bash
helm -n otel install my-splunk-otel-collector -f values.yaml splunk-otel-collector-chart/splunk-otel-collector
```

--------------------------------

### Example Kubernetes Log Error: Connection Refused

Source: https://github.com/splunk/public-o11y-docs/blob/main/infrastructure/network-explorer/network-explorer-troubleshoot.rst

Expected error messages on initial startup if the `k8s-relay` has not yet come up. These can be ignored.

```bash
Error: rpc error: code = Unavailable desc = connection error: desc = "transport: Error while dialing dial tcp [::1]:8712: connect: connection refused"
```

--------------------------------

### Get Initial Collector Configuration

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/otel-commands.rst

Retrieves the initial configuration of the OpenTelemetry Collector agent. Use this to verify the collector's starting configuration.

```bash
kubectl exec -it my-splunk-otel-collector-agent-hg4gk -- curl http://localhost:55554/debug/configz/initial
```

--------------------------------

### Enable Runtime Metrics Collection in Node.js

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/configuration/advanced-nodejs-otel-configuration.rst

Use the start() function to pass settings for runtime metrics collection.

```javascript
start()
```

--------------------------------

### Detailed Health Check Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/components/health-check-extension.rst

A comprehensive configuration example demonstrating various settings including TLS, pipeline checks, and specific endpoints.

```yaml
health_check:
health_check/1:
  endpoint: "localhost:13"
  tls:
    ca_file: "/path/to/ca"
    key_file: "/path/to/key"
    cert_file: "/path/to/cert"
  check_collector_pipeline:
    enabled: false
    interval: "5m"
    exporter_failure_threshold: 5
health_check/missingendpoint:
  endpoint: ""
  check_collector_pipeline:
    enabled: false
    interval: "5m"
    exporter_failure_threshold: 5
health_check/invalidthreshold:
  endpoint: "localhost:13"
  check_collector_pipeline:
    enabled: false
    interval: "5m"
    exporter_failure_threshold: -1
health_check/invalidpath:
  endpoint: "localhost:13"
  path: "invalid"
  check_collector_pipeline:
    enabled: false
    interval: "5m"
    exporter_failure_threshold: 5
```

--------------------------------

### Start OpenTelemetry Span

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/go/troubleshooting/migrate-signalfx-go-to-otel.rst

Shows how to start a new span within a given context using the created tracer. This replaces the older tracer.StartSpan method.

```go
ctx, span := tracer.Start(ctx, "BusinessOperation", /* options ... */)
```

--------------------------------

### Start tracing with custom spans

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/instrumentation/manual-instrumentation.rst

Use this to send custom traces to Splunk Observability Cloud. Ensure you have the required dependencies installed and tracing configured.

```javascript
const { start } = require('@splunk/otel');
const opentelemetry = require('@opentelemetry/api');

start({
  serviceName: 'my-service',
});

const tracer = opentelemetry.trace.getTracer('example-app', '0.1.0');

function randomNumber() {
  return tracer.startActiveSpan('make-random', (span) => {
    const result = Math.random() * 42;
    span.setAttribute('random-result', result);
    span.end();
    return result;
  });
}

setInterval(() => {
  console.log(randomNumber());
}, 1000);

```

--------------------------------

### Convertible SignalFlow Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/data-visualization/charts/chart-builder.rst

This example demonstrates SignalFlow that can be converted to the graphical plot-builder UI. Each stream is assigned to a capital letter, and the logic is simple.

```none
A = data('cpu.utilization').(label='A')
B = data('cpu.utilization').publish(label='B')
C = (A/B+10).publish(label='C')
```

--------------------------------

### Install Helm Chart with PSP

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/kubernetes-config-advanced.rst

Install the Helm chart after configuring the PSP and custom ClusterRole rule. Ensure to specify your values file.

```bash
helm install my-splunk-otel-collector -f my_values.yaml splunk-otel-collector-chart/splunk-otel-collector
```

--------------------------------

### Activate Node.js Runtime Metrics

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/configuration/nodejs-otel-metrics.rst

Pass the runtimeMetricsEnabled argument to the start method to activate runtime metrics collection. Ensure the @splunk/otel package is installed.

```javascript
const { start } = require('@splunk/otel');

start({
   serviceName: 'my-service',
   metrics: {
     runtimeMetricsEnabled: true,
   }
});
```

--------------------------------

### Install Private Runner on MacOS/Windows with Podman

Source: https://github.com/splunk/public-o11y-docs/blob/main/synthetics/test-config/private-locations.rst

Starts a private runner container using Podman on MacOS or Windows. Includes disabling network shaping and requires the RUNNER_TOKEN.

```shell
podman run -e "DISABLE_NETWORK_SHAPING=true" -e "RUNNER_TOKEN=YOUR_TOKEN_HERE" \
 quay.io/signalfx/splunk-synthetics-runner:latest
```

--------------------------------

### Create TracerProvider entry point in PHP

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/php-manual-instrumentation.rst

Acquire the TracerProvider entry point. This is typically done once at the application's startup.

```php
$tracerProvider = Globals::tracerProvider();
```

--------------------------------

### Basic Collector Deployment with Puppet

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-windows/deployments-windows-puppet.rst

Use this to install and configure the Collector with default parameters. Replace placeholders with your specific values.

```ruby
class {
  splunk_otel_collector:
    collector_version => 'VERSION',
    splunk_access_token => 'SPLUNK_ACCESS_TOKEN',
    splunk_realm => 'SPLUNK_REALM',
  }
}
```

--------------------------------

### Configure Helm Chart for Kubernetes Operator

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/k8s/k8s-backend.rst

Define settings for activating or deactivating the OpenTelemetry Collector when installing with the Helm Chart. This example shows how to set the cluster name.

```yaml
clusterName: <your_cluster_name>
```

--------------------------------

### Install Collector with Systemd Instrumentation

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

Run the installer script with the --with-systemd-instrumentation option for systemd-based services. This automatically configures environment variables for auto-instrumentation.

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh && \
                            sudo sh /tmp/splunk-otel-collector.sh --with-systemd-instrumentation --realm <SPLUNK_REALM> -- <SPLUNK_ACCESS_TOKEN>
```

--------------------------------

### Install Collector with Systemd Instrumentation and Profiling

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

This command installs the collector, enables systemd instrumentation, and activates AlwaysOn Profiling for CPU, memory, and metrics. Ensure you replace the realm and access token placeholders.

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh && \
sudo sh /tmp/splunk-otel-collector.sh --with-systemd-instrumentation --deployment-environment prod \
--realm <SPLUNK_REALM> -- <SPLUNK_ACCESS_TOKEN> \
--enable-profiler --enable-profiler-memory --enable-metrics
```

--------------------------------

### Install Zero-Code Instrumentation Package (RPM)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the zero-code instrumentation package on RPM-based systems. Replace `<path to splunk-otel-auto-instrumentation rpm>` with the actual file path.

```bash
rpm -ivh <path to splunk-otel-auto-instrumentation rpm>
```

--------------------------------

### Logstash Configuration for Metrics

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/monitors-network/logstash-tcp.rst

Example Logstash configuration demonstrating the use of 'timer' and 'meter' metrics from the Logstash Metrics filter plugin. This setup collects 'process_time' and 'logins.count' metrics.

```yaml
input {
  file {
    path => "/var/log/auth.log"
    start_position => "beginning"
    tags => ["auth_log"]
  }

  # A contrived file that contains timing messages
  file {
    path => "/var/log/durations.log"
    tags => ["duration_log"]
    start_position => "beginning"
  }
}

filter {
  if "duration_log" in [tags] {
    dissect {
      mapping => {
        "message" => "Processing took %{duration} seconds"
      }
      convert_datatype => {
        "duration" => "float"
      }
    }
    if "_dissectfailure" not in [tags] { # Filter out bad events
      metrics {
        timer => { "process_time" => "%{duration}" }
        flush_interval => 10
        # This makes the timing stats pertain to only the previous 5 minutes
        # instead of since Logstash last started.
        clear_interval => 300
        add_field => {"type" => "processing"}
        add_tag => "metric"
      }
    }
  }
  # Count the number of logins using SSH from /var/log/auth.log
  if "auth_log" in [tags] and [message] =~ /sshd.*session opened/ {
    metrics {
      # This determines how often metric events will be sent to the agent, and
      # thus how often data points will be emitted.
      flush_interval => 10
      # The name of the meter will be used to construct the name of the metric
      # in Splunk Infrastructure Monitoring. For this example, a data point called `logins.count` would
      # be generated.
      meter => "logins"
      add_tag => "metric"
    }
  }
}

output {
  # This can be helpful to debug
  stdout { codec => rubydebug }

  if "metric" in [tags] {
    tcp {
      port => 8900
      # The agent will connect to Logstash
      mode => "server"
      # Needs to be "0.0.0.0" if running in a container.
      host => "127.0.0.1"
    }
  }
}
```

--------------------------------

### Install Network Explorer with Helm

Source: https://github.com/splunk/public-o11y-docs/blob/main/infrastructure/network-explorer/network-explorer-setup.rst

Install the Network Explorer using the Helm chart, specifying the namespace, gateway address, and other configuration options. Ensure RBAC and service accounts are created.

```bash
helm --namespace=<NAMESPACE> install my-opentelemetry-ebpf \
    --set="endpoint.address=<address_of_gateway>" \
    --set="podSecurityPolicy.enabled=false" \
    --set="rbac.create=true" \
    --set="k8sCollector.serviceAccount.create=true" \
    --set="kernelCollector.serviceAccount.create=true" \
    --set="kernelCollector.image.tag=4.18.0-372.51.1.el8_6.x86_64" \
    --set="kernelCollector.image.name=kernel-collector-openshift" \
    open-telemetry/opentelemetry-ebpf
```

--------------------------------

### Update Node.js Agent Path

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

Manually update the NODE_OPTIONS environment variable if the Node.js agent is installed in a non-default path. This example shows how to configure it for system-wide services or systemd services.

```yaml
NODE_OPTIONS=-r /custom/nodejs/install/path/@splunk/otel/instrument
```

--------------------------------

### NGINX Configuration for OPcache PHP Script

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/monitors-cache/opcache.rst

Example NGINX configuration to serve the OPcache status PHP script. This setup restricts access to localhost and defines the script's location and handler.

```yaml
location ~ /monitoring/.*\.php$ {
    #access_log off;
    allow 127.0.0.1;
    allow ::1;
    deny all;
    include fastcgi_params;
    fastcgi_split_path_info ^(.+\.php)(/.*)$;
    fastcgi_param  PHP_ADMIN_VALUE "open_basedir=/var/log:/usr/bin:/srv/http/monitoring";
    fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    fastcgi_pass php-handler;
}
```

--------------------------------

### Install Zero-Code Instrumentation Package (Debian)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the zero-code instrumentation package on Debian-based systems. Replace `<path to splunk-otel-auto-instrumentation deb>` with the actual file path.

```bash
dpkg -i <path to splunk-otel-auto-instrumentation deb>
```

--------------------------------

### Activate Splunk OTel Python agent

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/python/instrumentation/instrument-python-application.rst

Activate the Splunk OTel Python agent by prefixing your Python service command with 'opentelemetry-instrument'. This example shows how to instrument a service started with 'python3 main.py --port=8000'.

```bash
opentelemetry-instrument python3 main.py --port=8000
```

--------------------------------

### Start metrics collection with custom resource attributes

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/instrumentation/manual-instrumentation.rst

Configure custom application metrics to be sent to Splunk Observability Cloud. This example shows how to set a custom service name and merge custom resource attributes.

```javascript
const { start } = require('@splunk/otel');
const { Resource } = require('@opentelemetry/resources');
const { metrics } = require('@opentelemetry/api');

// All fields are optional.
start({
  // Takes preference over OTEL_SERVICE_NAME environment variable
  serviceName: 'my-service',
  metrics: {
    // The suggested resource is filled in using OTEL_RESOURCE_ATTRIBUTES
    resourceFactory: (suggestedResource: Resource) => {
      return suggestedResource.merge(new Resource({
        'my.property': 'xyz',
        'build': 42,
      }));
    },
    exportIntervalMillis: 1000, // default: 5000
    // The default exporter used is OTLP over HTTP
    endpoint: 'http://collector:4318',
  },
});

const meter = metrics.getMeter('my-meter');
const counter = meter.createCounter('clicks');
counter.add(3);

```

--------------------------------

### Install Homebrew Package Manager

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-kubernetes/collector-configuration-tutorial-k8s/collector-config-tutorial-start.rst

Run this command to install the Homebrew package manager if it's not already installed on your macOS system.

```bash
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

--------------------------------

### Install React Native RUM Library

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/rum/react/install-rum-react.rst

Install the React Native RUM library using npm or yarn. For iOS, also install the pod.

```bash
# npm
npm install @splunk/otel-react-native

# yarn
yarn add @splunk/otel-react-native

(cd ios && pod install)
```

--------------------------------

### Install Collector with System-Wide Instrumentation and Deployment Environment

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

This command installs the collector with system-wide instrumentation and sets the 'deployment.environment' resource attribute. Replace '<env>' with your desired environment name (e.g., 'prod').

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh && \
sudo sh /tmp/splunk-otel-collector.sh --with-instrumentation --deployment-environment prod \
--realm <SPLUNK_REALM> -- <SPLUNK_ACCESS_TOKEN>
```

--------------------------------

### Download and Display Installer Script Options

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux.rst

Download the Splunk OpenTelemetry Collector installation script for Linux and display its available configuration options using the -h flag.

```bash
curl -sSL https://dl.signalfx.com/splunk-otel-collector.sh > /tmp/splunk-otel-collector.sh;
sh /tmp/splunk-otel-collector.sh -h
```

--------------------------------

### Install OpenTelemetry PHP Extension (Linux)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/php/instrument-php-application.rst

Install the OpenTelemetry PHP extension using PECL on Linux systems. Ensure build tools are installed first.

```shell
sudo apt-get install gcc make autoconf
pecl install opentelemetry
```

--------------------------------

### Install Private Runner with Helm

Source: https://github.com/splunk/public-o11y-docs/blob/main/synthetics/test-config/private-locations.rst

Installs the Splunk Synthetics runner using Helm. Ensure you have Helm installed and the repository added. Replace YOUR_TOKEN_HERE with your actual runner token.

```shell
helm repo add synthetics-helm-charts https://splunk.github.io/synthetics-helm-charts/
helm repo update
helm install my-splunk-synthetics-runner synthetics-helm-charts/splunk-synthetics-runner \
--set=synthetics.secret.runnerToken=YOUR_TOKEN_HERE \
--set synthetics.secret.create=true
```

--------------------------------

### Install splunk-otel-auto-instrumentation Package (Debian/RPM)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/automatic-discovery/linux/linux-backend.rst

Use these commands to install the auto-instrumentation package after downloading it from GitHub Releases. Replace the placeholder with the actual path to your downloaded .deb or .rpm file.

```bash
sudo dpkg -i <path to splunk-otel-auto-instrumentation deb>
```

```bash
sudo rpm -Uvh <path to splunk-otel-auto-instrumentation rpm>
```

--------------------------------

### Install Collector on Debian using Package Repository

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the Splunk OpenTelemetry Collector on Debian-based systems by setting up the package repository and installing the collector package. Requires curl and apt-get.

```bash
curl -sSL https://splunk.jfrog.io/splunk/otel-collector-deb/splunk-B3CD4420.gpg > /etc/apt/trusted.gpg.d/splunk.gpg
echo 'deb https://splunk.jfrog.io/splunk/otel-collector-deb release main' > /etc/apt/sources.list.d/splunk-otel-collector.list
apt-get update
apt-get install -y splunk-otel-collector
```

--------------------------------

### Initialize Terraform Directory

Source: https://github.com/splunk/public-o11y-docs/blob/main/apm/apm-data-links/apm-datalinks-terraform/apm-create-data-links-terraform-file.rst

Run this command in your working directory to initialize Terraform and download the necessary provider plugins.

```none
terraform init
```

--------------------------------

### Configure Signals with start() arguments

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/get-data-in/application/nodejs/version-2x/configuration/advanced-nodejs-otel-configuration.rst

Configure specific data types like metrics, profiling, or tracing by passing an object with corresponding properties to the start() function. This allows for detailed configuration of each signal.

```javascript
start({
   // general options like `serviceName` and `endpoint`
   metrics: {
      // configuration passed to metrics signal
   },
   profiling: {
      // configuration passed to profiling signal
   },
   tracing: {
      // configuration passed to tracing signal
   },
});
```

--------------------------------

### Install Splunk OpenTelemetry Collector from RPM Package (Zypper)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the Splunk OpenTelemetry Collector from a downloaded RPM package using Zypper. This requires installing the libcap-progs dependency and then the RPM package.

```bash
zypper install -y libcap-progs  # Required for enabling cap_dac_read_search and cap_sys_ptrace capabilities on the Collector
rpm -ivh <path to splunk-otel-collector rpm>
```

--------------------------------

### Install Splunk OpenTelemetry Collector from RPM Package (DNF)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the Splunk OpenTelemetry Collector from a downloaded RPM package using DNF. This requires installing the libcap dependency and then the RPM package.

```bash
dnf install -y libcap  # Required for enabling cap_dac_read_search and cap_sys_ptrace capabilities on the Collector
rpm -ivh <path to splunk-otel-collector rpm>
```

--------------------------------

### SQL Monitor Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/monitors-databases/sql.rst

Configure the SQL monitor with connection details and queries. Ensure the connection string syntax matches the specified dbDriver.

```yaml
smartagent/sql:
  type: sql
  host: localhost
  port: 1433
  dbDriver: sqlserver
  connectionString: 'Server=127.0.0.1;Database=WideWorldImporters;User Id=sa;Password=123456;'
  queries: 
    - query: 'SELECT COUNT(*) as count FROM Sales.Orders'
      metrics:
        - metricName: "orders"
          valueColumn: "count"
```

--------------------------------

### Install Splunk OpenTelemetry Collector from RPM Package (YUM)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the Splunk OpenTelemetry Collector from a downloaded RPM package using YUM. This requires installing the libcap dependency and then the RPM package.

```bash
yum install -y libcap  # Required for enabling cap_dac_read_search and cap_sys_ptrace capabilities on the Collector
rpm -ivh <path to splunk-otel-collector rpm>
```

--------------------------------

### Install Splunk OpenTelemetry Collector with RPM (Zypper)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the Splunk OpenTelemetry Collector using a Zypper package manager. This involves setting up the repository and installing the collector and optional auto-instrumentation package.

```bash
zypper install -y libcap-progs  # Required for enabling cap_dac_read_search and cap_sys_ptrace capabilities on the Collector

cat <<EOH > /etc/zypp/repos.d/splunk-otel-collector.repo
[splunk-otel-collector]
name=Splunk OpenTelemetry Collector Repository
baseurl=https://splunk.jfrog.io/splunk/otel-collector-rpm/release/
$basearch
gpgcheck=1
gpgkey=https://splunk.jfrog.io/splunk/otel-collector-rpm/splunk-B3CD4420.pub
enabled=1
EOH

zypper install -y splunk-otel-collector

# Optional: install Splunk OpenTelemetry zero-code instrumentation
zypper install -y splunk-otel-auto-instrumentation
```

--------------------------------

### Activate Java Profiler using System Property

Source: https://github.com/splunk/public-o11y-docs/blob/main/apm/profiling/get-data-in-profiling.rst

Example of activating the Java profiler using system properties for CPU and memory profiling. Ensure the OTLP endpoint is correctly configured.

```bash
# Activate CPU profiling
-Dsplunk.profiler.enabled=true
# Activate memory profiling
-Dsplunk.profiler.memory.enabled=true
# Set the profiling-specific OTLP endpoint
-Dsplunk.profiler.logs-endpoint=http://localhost:4317
```

--------------------------------

### Smart Agent Configuration Example

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/smart-agent/smart-agent-migration-monitors.rst

This YAML configuration sets up receivers for PostgreSQL, process list, and Kafka, along with resource detection processors and SignalFx/OTLP exporters. It defines pipelines for metrics, logs, and traces.

```yaml
receivers:
   smartagent/postgresql:
      type: postgresql
      host: mypostgresinstance
      port: 5432
      dimensionClients:
         - signalfx
   smartagent/processlist:
      type: processlist
   smartagent/kafka:
      type: collectd/kafka
      host: mykafkabroker
      port: 7099
      clusterName: mykafkacluster
      intervalSeconds: 5

processors:
   resourcedetection:
      detectors:
         - system

exporters:
   signalfx:
      access_token: "${SIGNALFX_ACCESS_TOKEN}"
      realm: us1
   otlphttp:
      access_token: "${SIGNALFX_ACCESS_TOKEN}"
      traces_endpoint: https://ingest.us1.signalfx.com/v2/trace/otlp

service:
   pipelines:
      metrics:
         receivers:
            - smartagent/postgresql
            - smartagent/kafka
            - otlp
         processors:
            - resourcedetection
         exporters:
            - signalfx
      logs:
         receivers:
            - smartagent/processlist
         processors:
            - resourcedetection
         exporters:
            - signalfx
      traces:
         receivers:
            - otlp
         processors:
            - resourcedetection
         exporters:
            - otlphttp
```

--------------------------------

### Install Splunk OpenTelemetry Collector with RPM (DNF)

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-linux/install-linux-manual.rst

Installs the Splunk OpenTelemetry Collector using a DNF package manager. This includes setting up the repository and installing the collector and optional auto-instrumentation package.

```bash
dnf install -y libcap  # Required for enabling cap_dac_read_search and cap_sys_ptrace capabilities on the Collector

cat <<EOH > /etc/yum.repos.d/splunk-otel-collector.repo
[splunk-otel-collector]
name=Splunk OpenTelemetry Collector Repository
baseurl=https://splunk.jfrog.io/splunk/otel-collector-rpm/release/
$basearch
gpgcheck=1
gpgkey=https://splunk.jfrog.io/splunk/otel-collector-rpm/splunk-B3CD4420.pub
enabled=1
EOH

dnf install -y splunk-otel-collector

# Optional: install Splunk OpenTelemetry zero-code instrumentation
dnf install -y splunk-otel-auto-instrumentation
```

--------------------------------

### Example TLS Client Configuration

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/common-config/collector-common-config-tls.rst

Configure TLS settings for an OTLP exporter, including certificate files, key files, and minimum/maximum TLS versions. This example demonstrates a secure connection.

```yaml
exporters:
  otlp:
    endpoint: myserver.local:55690
    tls:
      insecure: false
      ca_file: server.crt
      cert_file: client.crt
      key_file: client.key
      min_version: "1.1"
      max_version: "1.2"
```

--------------------------------

### Install Splunk OpenTelemetry Collector using Chocolatey

Source: https://github.com/splunk/public-o11y-docs/blob/main/gdi/opentelemetry/collector-windows/install-windows-msi.rst

This command installs the Splunk OpenTelemetry Collector using a Chocolatey package. It allows for configuration of the access token and realm directly through parameters during installation.

```PowerShell
choco install splunk-otel-collector --params="'/SPLUNK_ACCESS_TOKEN:MY_SPLUNK_ACCESS_TOKEN /SPLUNK_REALM:MY_SPLUNK_REALM'"
```
Tokens:
Raw