splunk-otel 0.1.0

data/README.md

@@ -0,0 +1,190 @@
+# Splunk Distribution of OpenTelemetry Ruby
+
+<p align="left">
+  <a href="https://github.com/signalfx/gdi-specification/releases/tag/v1.2.0">
+    <img alt="Splunk GDI specification" src="https://img.shields.io/badge/GDI-1.2.0-blueviolet?style=for-the-badge">
+  </a>
+  <a href="https://github.com/signalfx/splunk-otel-ruby/actions?query=workflow%3A%22Ruby+CI%22">
+    <img alt="Build Status" src="https://img.shields.io/github/workflow/status/signalfx/splunk-otel-ruby/Ruby%20CI?style=for-the-badge">
+  </a>
+</p>
+
+The Splunk Distribution of [OpenTelemetry Instrumentation for
+Ruby](https://github.com/open-telemetry/opentelemetry-ruby) provides a gem for
+setup of OpenTelemetry SDK for reporting distributed traces to [Splunk
+APM](https://docs.splunk.com/Observability/apm/intro-to-apm.html).
+
+This distribution comes with the following defaults:
+
+- [W3C tracecontext and baggage propagation](https://www.w3.org/TR/trace-context).
+- [OTLP exporter](https://rubygems.org/gems/opentelemetry-exporter-otlp)
+  configured to send spans to a locally running [OpenTelemetry
+  Collector](https://github.com/open-telemetry/opentelemetry-collector) over
+  HTTP (default endpoint: `localhost:4318`).
+- Unlimited default limits for [configuration options](#trace-configuration) to
+  support full-fidelity traces.
+
+## Requirements
+
+- Ruby 2.6+
+
+## Get started
+
+This Splunk distribution comes with the following defaults:
+
+- [W3C tracecontext](https://www.w3.org/TR/trace-context/) and [W3C
+  baggage](https://www.w3.org/TR/baggage/) context propagation.
+- OTLP over HTTP exporter configured to send spans to a locally running [Splunk
+  OpenTelemetry Connector](https://github.com/signalfx/splunk-otel-collector)
+  (http://localhost:4318).
+- Unlimited default limits for configuration options to support full-fidelity
+  traces.
+
+Install the gem by adding it to your project's `Gemfile`:
+
+``` ruby
+gem "splunk-otel", "~> 0.1"
+```
+
+Configure OpenTelemetry using the `Splunk::Otel` module from `splunk/otel`:
+
+``` ruby
+require "splunk/otel"
+...
+Splunk::Otel.configure
+```
+
+## Basic configuration
+
+The `service.name` resource attribute is the only configuration option that
+needs to be specified, using either the environment variable `OTEL_SERVICE_NAME`
+or passing as an argument to `configure`:
+
+``` ruby
+Splunk::Otel.configure(service_name: "my-service")
+```
+
+Other resource attributes are not strictly required, but
+`deployment.environment` and `service.version` are recommended to be set if they
+are available. These can be set through the environment variable
+`OTEL_RESOURCE_ATTRIBUTES`:
+
+``` 
+OTEL_RESOURCE_ATTRIBUTES="service.version=1.2.3,deployment.environment=production"
+```
+
+## Advanced configuration
+
+See [advanced-config.md](docs/advanced-config.md) for information on how to
+configure the instrumentation.
+
+## Correlate traces and logs
+
+You can add trace metadata to logs using the OpenTelemetry trace API. Trace
+metadata lets you explore logs in Splunk Observability Cloud.
+
+See [Correlating traces and logs](docs/correlating-traces-and-logs.md) for more information.
+
+## Library instrumentation
+
+Supported libraries are listed
+[here](https://github.com/open-telemetry/opentelemetry-ruby/tree/main/instrumentation).
+The corresponding gems for the instrumentation libraries can be found under the
+[opentelemetry-ruby](https://rubygems.org/profiles/opentelemetry-ruby) profile
+on [rubygems.org](https://rubygems.org).
+
+### Automatic instrumentation
+
+You can enable automatic instrumentation of all libraries used in your project
+that have corresponding [OpenTelemetry Ruby
+gems](https://rubygems.org/profiles/opentelemetry-ruby) libraries by installing
+the
+[opentelemetry-instrumentation-all](https://rubygems.org/gems/opentelemetry-instrumentation-all)
+gem in your Gemfile:
+
+``` ruby
+gem "opentelemetry-instrumentation-all", "~> 0.23" 
+```
+
+Enable the instrumentations from the gem by passing `auto_instrument:true` to
+the `configure` method of `Splunk::Otel`. For example:
+
+``` ruby
+require "splunk/otel"
+
+Splunk::Otel.configure(auto_instrument: true)
+```
+
+The gem fetches all instrumentation libraries but only enables those that
+instrument a dependency in your project. For example, it will fetch
+`opentelemetry-instrumentation-rack` but only if the `rack` gem is included and
+used in your project will the instrumentation be enabled.
+
+`auto_instrument: true` also works if individual instrumentation libraries are
+installed, like the `opentelemetry-instrumentation-sinatra` gem.
+
+To set configuration of one or more instrumentation libraries a config hash
+can be passed to `use_all`:
+
+``` ruby
+OpenTelemetry::SDK.configure do |c|
+  config = {'OpenTelemetry::Instrumentation::Redis' => { opt: "value" }}
+  c.use_all(config)
+end
+```
+
+The option `enabled` can be used to disable individual instrumentation libraries
+when using `opentelemetry-instrumentation-all`:
+
+``` ruby
+OpenTelemetry::SDK.configure do |c|
+  config = {'OpenTelemetry::Instrumentation::Redis' => { enabled: false }}
+  c.use_all(config)
+end
+```
+
+To enable instrumentation libraries manually, see [Manual instrumentation](#manually-instrument-code).
+
+### Manual instrumentation
+
+Instrumentation gems can also be installed and enabled individually. This may be
+preferred in order to control exactly which gems are fetched when building your project.
+
+Install the instrumentation library by including it in
+the project's `Gemfile`. For example, to install the
+[Sinatra](https://rubygems.org/gems/opentelemetry-instrumentation-sinatra)
+instrumentation:
+
+``` 
+gem "opentelemetry-instrumentation-sinatra", "~> 0.19"
+```
+
+In a block passed to `Splunk::Otel.configure` configure the SDK to use
+each of the instrumentation libraries. In the case of the Sinatra instrumentation,
+the block would look like the following example:
+
+``` ruby
+require "splunk/otel"
+
+Splunk::Otel.configure do |c|
+  c.use "OpenTelemetry::Instrumentation::Sinatra", { opt: "value" }
+end
+```
+
+## Troubleshooting
+
+For troubleshooting information, see the [Troubleshooting](docs/troubleshooting.md) documentation.
+
+# License
+
+The Splunk OpenTelemetry Ruby distribution is released under the terms of the
+Apache Software License version 2.0. For more details, see [the license
+file](./LICENSE).
+
+> Copyright 2021 Splunk Inc.
+>
+> Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+>
+> http://www.apache.org/licenses/LICENSE-2.0
+>
+> Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

data/Rakefile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "rubocop/rake_task"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/SECURITY.md

@@ -0,0 +1,7 @@
+# Security
+
+## Reporting Security Issues
+
+Please *DO NOT* report security vulnerabilities with public GitHub issue
+reports. Please [report security issues here](
+https://www.splunk.com/en_us/product-security/report.html).

data/conf/otel-collector-config.yaml

@@ -0,0 +1,21 @@
+receivers:
+  otlp:
+    protocols:
+      http:
+        endpoint: "0.0.0.0:4318"
+
+processors:
+  batch:
+
+exporters:
+  logging:
+  httpsink:
+    endpoint: "0.0.0.0:8378"
+
+service:
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: []
+      # processors: [batch]
+      exporters: [logging, httpsink]

data/docker-compose.yml

@@ -0,0 +1,11 @@
+version: "3"
+services:
+  otel:
+    image: quay.io/signalfx/splunk-otel-collector:latest
+    command: ["--config=/conf/otel-collector-config.yaml"]
+    privileged: true
+    ports:
+      - 4318:4318
+      - 8378:8378
+    volumes:
+      - ./conf/otel-collector-config.yaml:/conf/otel-collector-config.yaml

data/docs/README.md

@@ -0,0 +1,3 @@
+The official documentation for this distribution can be found here:
+
+https://docs.splunk.com/Observability/gdi/get-data-in/application/ruby/get-started.html

data/docs/advanced-config.md

@@ -0,0 +1,52 @@
+# Advanced configuration
+
+## Trace exporters
+
+| Environment variable              | Default value                    | Support     | Description                                                                                                                              |
+| --------------------------------- | -------                          | ----------- | ---                                                                                                                                      |
+| `OTEL_TRACES_EXPORTER`            | `otlp`                           | Stable      | Select the traces exporter to use. We recommend using the OTLP exporter (`otlp`).
+| `OTEL_EXPORTER_OTLP_ENDPOINT`     | `http://localhost:4318`          | Stable      | The OTLP endpoint to connect to.
+
+The Splunk Distribution of OpenTelemetry Ruby uses the OTLP traces exporter as
+the default setting. For debugging purposes, use the `console` exporter, which writes
+spans directly to the console.
+
+An example of setting an alternate trace exporter:
+
+```
+export OTEL_TRACES_EXPORTER=console
+```
+
+## Exporting directly to Splunk Observability Cloud
+
+To export traces directly to Splunk Observability Cloud, bypassing the Collector,
+set the `SPLUNK_ACCESS_TOKEN` and `SPLUNK_REALM` environment variables.
+
+| Environment variable                   | Default value | Support     | Description                                                                                                                                          |
+| -------------------------------------- | ------------  | ----------- | ---                                                                                                                                                  |
+| `SPLUNK_ACCESS_TOKEN`                  | unset         | Stable      | Splunk authentication token that lets exporters send data directly to Splunk Observability Cloud. Unset by default. Not required unless you need to send data to the Observability Cloud ingest endpoint. See [Create and manage authentication tokens using Splunk Observability Cloud](https://docs.splunk.com/Observability/admin/authentication-tokens/tokens.html#admin-tokens).                               |
+| `SPLUNK_REALM`                         | us0           | Stable      | The name of your organization’s realm, for example, us0. When you set the realm, traces are sent directly to the ingest endpoint of Splunk Observability Cloud, bypassing the Splunk OpenTelemetry Collector. |
+
+## Propagators configuration
+
+| Environment variable | Default value        | Support | Description                                                                                        |
+| `OTEL_PROPAGATORS`     | `tracecontext,baggage` | Stable  | Comma-separated list of propagator names to be used. |
+
+To keep backward compatibility with manual instrumentation for the SignalFx Ruby Tracing library, set the trace propagator to B3:
+
+```
+export OTEL_PROPAGATORS=b3multi
+```
+
+## Trace configuration
+
+| Environment variable      | Config Option         | Default value             | Notes                                                                                                                                                                                                         |
+| ------------------------- | --------------------- | ------------------------- | ----------------------------------------------------------------------                                                                                                                                        |
+| OTEL_SERVICE_NAME                 | service_name          | `unnamed-ruby-service`  | The service name of this Ruby application. |
+| OTEL_RESOURCE_ATTRIBUTES          |                       | unset                     | Comma-separated list of resource attributes added to every reported span. <details><summary>Example</summary>`service.name=my-ruby-service,service.version=3.1,deployment.environment=production`</details> |
+| OTEL_SPAN_ATTRIBUTE_COUNT_LIMIT   |                       | `""` (unlimited)          | Maximum number of attributes per span.  |
+| OTEL_EVENT_ATTRIBUTE_COUNT_LIMIT  |                       | `""` (unlimited)          | Maximum number of attributes per event.  |
+| OTEL_LINK_ATTRIBUTE_COUNT_LIMIT   |                       | `""` (unlimited)          | Maximum number of attributes per link.  |
+| OTEL_SPAN_EVENT_COUNT_LIMIT       |                       | `""` (unlimited)          | Maximum number of events per span. |
+| OTEL_SPAN_LINK_COUNT_LIMIT        |                       | `1000`                    | Maximum number of links per span. |
+| OTEL_ATTRIBUTE_VALUE_LENGTH_LIMIT |                       | `12000`                   | Maximum length of strings for span attribute values. Values larger than the limit are truncated. |

data/docs/correlating-traces-and-logs.md

@@ -0,0 +1,23 @@
+# Correlating trace and logs
+
+## Standard Ruby logger
+
+To add trace metadata of the current trace to logs, use the
+`Splunk::Otel::Logging.format_correlation` function of the 
+[Ruby standard logger](https://ruby-doc.org/stdlib-3.1.1/libdoc/logger/rdoc/Logger.html)
+to set the formatter, as in the following example:
+
+``` ruby
+require "splunk/otel"
+
+logger.formatter = proc do |severity, datetime, progname, msg|  
+  "#{Splunk::Otel::Logging.format_correlation} : #{msg}\n"
+end
+```
+
+This adds `service.name=<ServiceName> trace_id=<TraceId> span_id=<SpanId>` to each log line.
+
+```
+service.name=basic-service trace_id=789b159aaee2b389a8771b2588278bcf
+span_id=6d26eba14a81f3fa : show log correlation
+```

data/docs/instrumenting-rails.md

@@ -0,0 +1,7 @@
+# Instrumenting Rails
+
+TODO
+
+## Example
+
+See the [readme for Rails 7 barebones example](../examples/rails-7-barebones/README.md).

data/docs/troubleshooting.md

@@ -0,0 +1,14 @@
+# Troubleshooting
+
+## Enable debug logging
+
+When things are not working, a good first step is to restart the program with
+debug logging enabled. Do this by setting the `OTEL_LOG_LEVEL` environment
+variable to `debug`.
+
+```sh
+export OTEL_LOG_LEVEL="debug"
+```
+
+Make sure to unset the environment variable after the issue is resolved, as its
+output might overload systems if left on indefinitely.

data/examples/basic/README.md

@@ -0,0 +1,94 @@
+# Basic Splunk Otel Distro example
+
+The `console.rb` script will use the `splunk-otel` gem from the root of this repo
+as the dependency.
+
+Run the script and the function `BasicExample.some_spans` to create a couple spans and logs.
+
+``` shell
+$ ./console.rb
+irb(main):001:0> BasicExample.some_spans
+service.name=unnamed-ruby-service trace_id=01300273775f7550bf4af9f46097afd9 span_id=26737fe11ff026a5 : show log correlation
+=> true
+```
+
+### Export to console
+
+The environment variable `OTEL_TRACES_EXPORTER` can be set to `console` to see
+the spans printed to the console when exported:
+
+``` shell
+$ OTEL_TRACES_EXPORTER=console ./console.rb
+service.name=unnamed-ruby-service trace_id=2c9a43b23a08163e4a25c8e3736c7bda span_id=43d59546e5d1b434 : show log correlation
+#<struct OpenTelemetry::SDK::Trace::SpanData
+ name="span-2",
+ ...
+ parent_span_id="\x96\xDD\xC3&\xEE\xAE\xCB:",
+ ...
+ instrumentation_library=
+  #<struct OpenTelemetry::SDK::InstrumentationLibrary
+   name="mytracer",
+   version="">,
+ span_id="C\xD5\x95F\xE5\xD1\xB44",
+ trace_id=",\x9AC\xB2:\b\x16>J%\xC8\xE3sl{\xDA",
+ ...>
+#<struct OpenTelemetry::SDK::Trace::SpanData
+ name="span-1",
+ ...
+ parent_span_id="\x00\x00\x00\x00\x00\x00\x00\x00",
+ ...
+ instrumentation_library=
+  #<struct OpenTelemetry::SDK::InstrumentationLibrary
+   name="mytracer",
+   version="">,
+ span_id="\x96\xDD\xC3&\xEE\xAE\xCB:",
+ trace_id=",\x9AC\xB2:\b\x16>J%\xC8\xE3sl{\xDA",
+ ...>
+=> true
+```
+
+### Export to Splunk OTEL Collector
+
+``` 
+version: "3"
+services:
+  splunk-otel-collector:
+    image: quay.io/signalfx/splunk-otel-collector:latest
+    environment:
+    - SPLUNK_ACCESS_TOKEN=${SPLUNK_ACCESS_TOKEN}
+    - SPLUNK_REALM=${SPLUNK_REALM}
+    ports:
+    - "4318:4318"
+```
+
+From this (`examples/basic`) directory bring up the [Splunk OpenTelemetry Collector](https://github.com/signalfx/splunk-otel-collector):
+
+``` shell
+$ SPLUNK_ACCESS_TOKEN=<ACCESS TOKEN> SPLUNK_REALM=<REALM> docker-compose up
+```
+
+Run the example again:
+
+``` 
+$ OTEL_SERVICE_NAME=basic-ruby-distro-test-collector ./console.rb
+irb(main):001:0> BasicExample.some_spans
+service.name=basic-ruby-distro-test-collector trace_id=0d26692f5982a470a1487c2be5207d20 span_id=64573df1bef69199 : show log correlation
+```
+
+![Splunk APM Ruby Trace](collector_trace.png)
+
+### Direct export to Splunk
+
+The default exporter is `otlp` and can be used to export directly to Splunk by
+setting `SPLUNK_ACCESS_TOKEN` to a token for the organization you wish to export
+spans to:
+
+``` shell
+$ OTEL_SERVICE_NAME=basic-ruby-distro-test-direct SPLUNK_ACCESS_TOKEN=<ACCESS TOKEN> ./console.rb
+irb(main):001:0> BasicExample.some_spans
+service.name=basic-ruby-distro-test-direct trace_id=754ecd93f0254ef5995e10a854dc47ad
+span_id=8d6c02874000469b : show log correlation
+=> true
+```
+
+![Splunk APM Ruby Trace](direct_trace.png)

data/examples/basic/console.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/inline"
+
+gemfile do
+  source "https://rubygems.org"
+
+  gem "splunk-otel", path: "../../"
+  gem "opentelemetry-exporter-otlp", "~> 0.21.0"
+end
+
+require "splunk/otel"
+require "splunk/otel/logging"
+require "opentelemetry/exporter/otlp"
+require "net/http"
+require "json"
+
+# a basic example module showing configuration through the Splunk distro
+# and creating 2 spans and logs with trace correlation data
+module BasicExample
+  def some_spans
+    logger = Logger.new($stdout)
+    logger.level = Logger::INFO
+
+    logger.formatter = proc do |_severity, _datetime, _progname, msg|
+      "#{Splunk::Otel::Logging.format_correlation} : #{msg}\n"
+    end
+
+    Splunk::Otel.configure
+    tracer = OpenTelemetry.tracer_provider.tracer("mytracer")
+    tracer.in_span("basic-example-span-1") do |_span|
+      tracer.in_span("basic-example-span-2") do |_span|
+        logger.info("show log correlation")
+      end
+    end
+  end
+
+  def test
+    collector_host = ENV.fetch("COLLECTOR_HOST", "localhost")
+    collector_port = ENV.fetch("COLLECTOR_PORT", "8378").to_i
+
+    BasicExample.some_spans
+
+    response = Net::HTTP.get(collector_host, "/?timeout=20&count=1", collector_port)
+    spans = JSON.parse(response)
+
+    if spans.any? { |span| span["operationName"].to_s == "basic-example-span-1" }
+      exit 0
+    else
+      exit 1
+    end
+  end
+
+  module_function :some_spans, :test
+end
+
+if ENV.key?("TEST")
+  BasicExample.test
+else
+  require "irb"
+  IRB.start(__FILE__)
+end

data/examples/basic/docker-compose.yml

@@ -0,0 +1,9 @@
+version: "3"
+services:
+  splunk-otel-collector:
+    image: quay.io/signalfx/splunk-otel-collector:latest
+    environment:
+      - SPLUNK_ACCESS_TOKEN=${SPLUNK_ACCESS_TOKEN}
+      - SPLUNK_REALM=${SPLUNK_REALM}
+    ports:
+      - "4318:4318"

data/examples/rails-7-barebones/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_BIN: "bin"

data/examples/rails-7-barebones/.gitignore

@@ -0,0 +1 @@
+.bundle

data/examples/rails-7-barebones/Dockerfile

@@ -0,0 +1,16 @@
+FROM ruby:3-buster
+RUN apt-get update -qq && apt-get install -y nodejs netcat
+
+# ruby comes with older versions of bundler sometimes
+RUN gem install bundler -v "2.3.14"
+
+# WARNING
+# note: context is changed, see ../../docker-compose.rails-7-barebones.yml
+
+ADD ./ /splunk-otel-ruby
+ENV SPLUNK_OTEL_LOCATION="/splunk-otel-ruby"
+
+WORKDIR /splunk-otel-ruby/examples/rails-7-barebones
+RUN bundle install
+
+CMD ["bundle", "exec", "rackup", "app.ru", "--host", "0.0.0.0", "-p", "3000"]

data/examples/rails-7-barebones/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+ruby "3.1.2"
+
+# rails app
+gem "puma"
+gem "rails", "~> 7.0.3"
+
+# instrumentation
+gem "opentelemetry-instrumentation-rails", "~> 0.22.0"
+gem "splunk-otel", path: ENV.fetch("SPLUNK_OTEL_LOCATION", "../../")
+
+# tests
+gem "test-unit", "~> 3.0"

data/examples/rails-7-barebones/README.md

@@ -0,0 +1,24 @@
+# Rails 7 example
+
+## Starting
+
+```shell
+docker-compose up -d
+```
+
+Which starts:
+- Open Telemetry Collector preconfigured for end-to-end testing
+- Rails 7 application instance
+- Test runner
+
+You can check the output of E2E tests by running either:
+- `docker-compose logs tester`
+- `ruby tests-e2e/rails_7_barebones_test.rb` (reruns the tests from your machine)
+
+To create spans send requests to an endpoint:
+
+```
+curl http://localhost:3000/
+```
+
+The spans will be printed in the console (stdout), and they will also be sent to the Collector instance started by docker-compose.

data/examples/rails-7-barebones/app.ru

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require "rubygems"
+require "bundler/setup"
+Bundler.require :default
+
+require "action_controller/railtie"
+
+# TraceRequestApp is a minimal Rails application inspired by the Rails
+# bug report template for action controller.
+# https://github.com/rails/rails/blob/v6.0.0/guides/bug_report_templates/action_controller_gem.rb
+# The configuration is compatible with Rails 6.0
+class TraceRequestApp < Rails::Application
+  config.root = __dir__
+  config.hosts << "example.org"
+  secrets.secret_key_base = "secret_key_base"
+  config.eager_load = false
+
+  config.logger = Logger.new($stdout)
+  Rails.logger  = config.logger
+end
+
+Rails.application.initialize!
+
+run Rails.application
+
+# To run this example run the `rackup` command with this file
+# Example: rackup trace_request_demonstration.ru
+# Navigate to http://localhost:9292/
+# Spans for the requests will appear in the console

data/examples/rails-7-barebones/config/initializers/splunk_otel.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+ENV["OTEL_TRACES_EXPORTER"] = "console,otlp"
+Splunk::Otel.configure(service_name: "rails-7-barebones", auto_instrument: true)

data/examples/rails-7-barebones/docker-compose.yml

@@ -0,0 +1,34 @@
+services:
+  collector:
+    image: quay.io/signalfx/splunk-otel-collector:latest
+    command: ["--config=/conf/otel-collector-config.yaml"]
+    ports:
+      - 4318:4318
+      - 8378:8378
+    volumes:
+      - ../../conf/otel-collector-config.yaml:/conf/otel-collector-config.yaml
+
+  rails_7_barebones:
+    build:
+      context: ../../
+      dockerfile: ./examples/rails-7-barebones/Dockerfile
+    ports:
+      - 3000:3000
+    environment:
+      - OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://collector:4318/v1/traces
+    links:
+      - collector
+
+  tester:
+    build:
+      context: ../../
+      dockerfile: ./examples/rails-7-barebones/Dockerfile
+    links:
+      - rails_7_barebones
+      - collector
+    environment:
+      - APP_HOST=rails_7_barebones
+      - APP_PORT=3000
+      - COLLECTOR_HOST=collector
+      - COLLECTOR_PORT=8378
+    entrypoint: ["./wait-for.sh", "rails_7_barebones:3000", "--", "ruby", "tests-e2e/rails_7_barebones_test.rb"]