Tulip is OllyGarden's commercially supported distribution of the OpenTelemetry Collector. It provides a production-ready, enterprise-grade solution for collecting, processing, and exporting telemetry data.

Tulip is OllyGarden's commercially supported distribution of the OpenTelemetry Collector. It provides a production-ready, enterprise-grade solution targeting organizations that rely on the upstream collector but need vendor support for their chosen mix of components. Built on the latest stable OpenTelemetry Collector, Tulip packages a vetted manifest of receivers, processors, exporters, and connectors, ships a ready-to-run container image, and offers paid support that backstops customer deployments while contributing fixes upstream when appropriate.

• Quarterly Stable Releases: Tulip ships stable releases aligned with upstream OpenTelemetry Collector releases on a quarterly cadence
• LTS Releases: Every 18 months, Tulip designates a Long-Term Support (LTS) release that receives extended maintenance and backports

• Version Format: vYY.MM (year.month) - e.g., v25.11 (November 2025), v26.2 (February 2026)
• Quarterly Releases: Aligned with upstream OpenTelemetry Collector releases every quarter
• LTS Designation: Every 18 months, starting with v26.5 (May 2026)
• First Release: v25.11 (November 2025)

• Configuration Stability: Configuration format and options remain backward compatible within supported versions
• Telemetry Stability: Telemetry data generated by components maintains consistent format and semantics

For all supported releases (LTS and current stable):

• CVE Issues: All security vulnerabilities are backported to supported releases
• Performance Bugs: Performance regressions and critical performance issues are evaluated and backported when confirmed
• Critical Functional Bugs: Bugs that impact core collector functionality or cause data loss are backported to supported releases
• Non-critical bugs and feature enhancements are not backported; customers are encouraged to upgrade to the latest stable release

• Maintain release checklist: component validation, image build, integration smoke tests, documentation updates
• Tag releases with semantic versioning
• Release notes and upgrade playbooks provided with each release

For detailed release notes and migration guides, see the Releases page.

Tulip serves as OllyGarden's commercially supported OpenTelemetry Collector distribution, offering:

• Supported, production-ready collector distribution aligned with upstream releases
• Fast bug triage, upstream advocacy, and optional long-term support roadmap
• Hands-on support for a curated, upstream-aligned collector bundle

• Production-Ready: Carefully selected and tested components from OpenTelemetry core, contrib, and vetted third-party modules
• Container-First: Ready-to-run container images with support for Linux and macOS binaries
• Extensible: Customers may fork Tulip manifests as a starting point for custom distributions

This repository follows the same structure as the upstream OpenTelemetry Collector distributions template:

tulip/
├── cmd/
│   └── goreleaser/          # Goreleaser configuration generator
├── distributions/
│   └── tulip/               # Tulip distribution configuration
│       ├── manifest.yaml    # Component manifest
│       ├── config.yaml      # Default configuration
│       ├── Dockerfile       # Container image definition
│       ├── tulip.service    # systemd service file
│       ├── tulip.conf       # systemd environment file
│       └── ...              # Installation scripts and Windows installer
├── scripts/
│   ├── build.sh             # Build script
│   └── generate-goreleaser.sh  # Generate goreleaser config
├── test/
│   └── ...                  # Test scripts and utilities
├── Makefile                 # Build automation
├── go.mod                   # Go module definition
└── README.md                # This file

Required:

• Go 1.22 or later
• OpenTelemetry Collector Builder (ocb) - automatically installed by the Makefile to ~/bin/ocb

Optional (for releases and packaging):

• GoReleaser - for building multi-platform binaries, packages, and container images

Note: GoReleaser is not required for local development and is fully available in GitHub Actions CI/CD workflows.

Build the Tulip distribution:

make build

This generates source code using ocb and compiles the binary to distributions/tulip/_build/tulip.

Generate source code only (without compilation):

make generate-sources

Generate all build artifacts (sources + goreleaser config):

make generate

Run tests:

make test

Run the full CI workflow:

make ci

This runs checks, builds the distribution, runs tests, and validates goreleaser configuration.

Format Go code:

go fmt ./...

Run this after making any Go code changes.

The Tulip distribution includes the following OpenTelemetry components:

Extensions:

• healthcheck - Health Check Extension
• pprof - pprof Extension for profiling
• basicauth - Basic Auth Extension
• bearertokenauth - Bearer Token Auth Extension
• oauth2client - OAuth2 Client Auth Extension
• oidc - OIDC Auth Extension

Receivers:

• otlp - OTLP Receiver supporting both gRPC and HTTP protocols

Exporters:

• nop - No-op Exporter for testing and debugging
• otlp - OTLP Exporter using gRPC protocol
• otlphttp - OTLP Exporter using HTTP protocol

All components are synchronized to the latest stable OpenTelemetry Collector release. See distributions/tulip/manifest.yaml for the complete component specification.

The default configuration is located at distributions/tulip/config.yaml. This configuration:

• Enables health check and pprof extensions
• Configures OTLP receiver with gRPC protocol
• Sets up a traces pipeline with OTLP exporters

For systemd deployments, configuration is managed via:

• /etc/tulip/config.yaml - Collector configuration
• /etc/tulip/tulip.conf - systemd environment variables

Tulip is available as a container image:

docker pull cr.olly.garden/ollygarden/tulip/tulip:v25.11.0

And other images versions can be found in the GitHub Container Registry.

After building, system packages (deb, rpm, apk) are available in the dist/ directory.

Tulip uses GitHub Actions for continuous integration and release automation. Workflows are located in .github/workflows/:

Continuous Integration (ci.yaml):

• Triggered on push to main and on pull requests
• Runs make ci which includes build, test, and goreleaser validation
• Uses Go 1.22 on Ubuntu 24.04

Release (release-tulip.yaml):

• Triggered when a GitHub release is published
• Builds multi-platform binaries, packages (deb, rpm, apk), and container images
• Publishes to GitHub Releases and GitHub Container Registry

Supported Release Platforms:

• Linux: amd64, arm64
• macOS: amd64, arm64

If you just want to see Tulip receive telemetry and write it to a file, you don’t need to understand the whole build and test setup.

Clone this repository and run the following commands:

From the repository root:

make build

This builds the Tulip binary at: distributions/tulip/_build/tulip

./distributions/tulip/_build/tulip --config=distributions/tulip/tulip-test.yaml

In another terminal, use telemetrygen to send traces to Tulip:

go run github.com/open-telemetry/opentelemetry-collector-contrib/cmd/telemetrygen@latest traces --otlp-endpoint localhost:4317 --otlp-insecure --rate 1 --duration 5s

Tulip’s demo config writes traces to a local JSON file:

cat test-output.json You should see attributes labeled with the service.namespace tulip-test and the environment demo.

• Generated source code: distributions/tulip/_build/
• Compiled binary: distributions/tulip/_build/tulip
• Release artifacts (when using goreleaser): dist/

Important: Files in _build/ are generated by ocb and should not be manually edited.

To add new components to the Tulip distribution:

1. Edit distributions/tulip/manifest.yaml
2. Add the component with its gomod path and version
3. Run make generate to regenerate build files and goreleaser config
4. Run go mod tidy to update dependencies
5. Run make build to build with the new component
6. Run make test to verify tests pass

To update component versions:

1. Edit distributions/tulip/manifest.yaml - update version numbers
2. Run make generate
3. Run go mod tidy
4. Run make test

Important: All OpenTelemetry components must use compatible versions. Contrib components and core components typically version together.

The .goreleaser.yaml file in distributions/tulip/ is generated by the make generate-goreleaser command. To modify release configuration:

1. Update the generator templates in cmd/goreleaser/
2. Run make generate-goreleaser
3. Verify changes in distributions/tulip/.goreleaser.yaml

Run the full CI workflow locally:

make ci

This will:

1. Run goreleaser validation checks
2. Build the distribution
3. Run all tests

Test a single distribution:

./test/test.sh -d tulip

Recommended workflow for making changes:

1. Make changes to manifest.yaml or other configuration files
2. Run make generate (regenerates sources and goreleaser config)
3. Run go mod tidy (update dependencies)
4. Run go fmt ./... (format code)
5. Run make test (verify tests pass)
6. Stage changes for review (per project guidelines)

• CLAUDE.md - Detailed development guidance and architecture notes
• OpenTelemetry Collector Documentation
• OpenTelemetry Collector Builder
• GoReleaser Documentation

Q: What's up with this name? A: Tulip represents a clean, structured blossom—fitting for a curated, supported collector bundle that helps telemetry "bloom" reliably.

Tulip is licensed under the Apache License, Version 2.0. See LICENSE for the full license text.

For Tulip support inquiries and to purchase a support plan:

• Contact OllyGarden at support@ollygarden.com
• Visit our support portal (available to customers with active support contracts)
• Visit ollygarden.com/tulip for pricing and support plan details

For upstream OpenTelemetry issues, please refer to the OpenTelemetry Collector repository.