[
{"title":"About / Credits","url":"/solr-orbit/about.html","content":"About / Credits License Apache Solr Orbit is licensed under the Apache License, Version 2.0. Attribution Apache Solr Orbit is derived from OpenSearch Benchmark (Copyright 2022 OpenSearch Contributors, licensed under Apache 2.0), which in turn derives from Elasticsearch Rally (Copyright Elasticsearch bv, licensed under Apache 2.0). Full attribution details are in the NOTICE file in the source repository. Trademarks Apache, Apache Solr, and the Apache feather logo are trademarks of The Apache S..."},
{"title":"aggregate","url":"/solr-orbit/reference/commands/aggregate.html","content":"aggregate Combines results from multiple benchmark runs into a single aggregated result. This is useful when you want statistical confidence in your benchmark numbers — running a workload three or more times and aggregating the results reduces the influence of any single outlier run. Two modes of aggregation Automatic aggregation (via run) Pass --test-iterations and --aggregate directly to the run command to execute the workload multiple times and aggregate automatically: solr-orbit run \\ --w..."},
{"title":"Anatomy of a Workload","url":"/solr-orbit/user-guide/understanding-workloads/anatomy-of-a-workload.html","content":"Anatomy of a workload A workload is a directory that describes a complete benchmark scenario: which Solr collection to create, what data to index, and which operations to run. All workload files are processed as Jinja2 templates before being parsed as JSON, which allows workload authors to parametrize any value and let users override it at run time. A workload contains the following files and directories: workload.json — the main descriptor: collections, corpora, and the default schedule. con..."},
{"title":"Available Configs","url":"/solr-orbit/cluster-config/available-configs.html","content":"Available Cluster Configs defaults Sets the Java heap to 1 GB (heap_size=1g). This is the baseline configuration that all other heap-size configs extend. heap_size: 1g Usage: solr-orbit run --cluster-config defaults ... 1gheap Sets the Solr JVM heap to 1 GB. Suitable for small workloads and testing. heap_size: 1g Usage: solr-orbit run --cluster-config 1gheap ... 2gheap Sets the Solr JVM heap to 2 GB. heap_size: 2g Usage: solr-orbit run --cluster-config 2gheap ... 4gheap Sets the Solr JVM heap..."},
{"title":"solr-orbitd","url":"/solr-orbit/reference/commands/benchmarkd.html","content":"solr-orbitd solr-orbitd is the daemon binary used for distributed load generation. It must be running on every worker machine before starting a distributed benchmark from the coordinator. Syntax solr-orbitd start --node-ip IP --coordinator-ip IP solr-orbitd stop --node-ip IP --coordinator-ip IP solr-orbitd restart --node-ip IP --coordinator-ip IP solr-orbitd status Subcommands Subcommand Description start Start the daemon and register with the coordinator stop Stop the running daemon restart ..."},
{"title":"Performance Testing Best Practices","url":"/solr-orbit/user-guide/optimizing-benchmarks/best-practices.html","content":"Performance Testing Best Practices Following consistent methodology produces benchmark results you can trust and compare over time. This page summarizes the most important practices for running Apache Solr Orbit. Use a dedicated, stable environment Benchmark results are only meaningful when the environment is consistent across runs. Avoid: Running other workloads on the benchmark host or the Solr nodes during the test Sharing the Solr cluster with production traffic Running benchmarks on lapt..."},
{"title":"Choosing a Workload","url":"/solr-orbit/user-guide/understanding-workloads/choosing-a-workload.html","content":"Choosing a Workload Overview The solr-orbit-workloads repository offers pre-built workloads for performance testing Apache Solr clusters. Selecting a workload that mirrors your cluster’s actual use cases streamlines the benchmarking process and reduces custom development overhead. A practical example: a rideshare company can leverage the nyc_taxis workload instead of building a proprietary benchmark, because the taxi trip dataset closely resembles operational geospatial and time-series data. ..."},
{"title":"collections","url":"/solr-orbit/reference/workloads/collections.html","content":"collections The \"collections\" array in workload.json defines the Solr collections to create before the benchmark starts. Syntax { \"collections\": [ { \"name\": \"<collection-name>\", \"configset-path\": \"<path>\", \"num-shards\": 1, \"replication-factor\": 1, \"tlog-replicas\": 0, \"pull-replicas\": 0 } ] } Fields Field Type Required Default Description name string Yes — The collection name. Must be a valid Solr collection name. configset-path string No — Path relative to the workload directory p..."},
{"title":"Command Flags","url":"/solr-orbit/reference/commands/command-flags.html","content":"Command Flags Complete reference of all solr-orbit command-line flags. Global flags Accepted by all subcommands. Flag Short Description --help -h Display help text for the current command and exit --offline — Run without network access; disables workload repository fetching and update checks --version -v Show version and exit --quiet — Suppress console output (except errors) run flags Workload selection Flag Type Default Description --workload string — Named workload (fetched from workloads r..."},
{"title":"Common Operations","url":"/solr-orbit/user-guide/understanding-workloads/common-operations.html","content":"Common Operations Apache Solr Orbit provides the following built-in operation types. bulk-index Indexes documents from a corpus into a Solr collection in batches. { \"name\": \"bulk-index\", \"operation-type\": \"bulk-index\", \"bulk-size\": 500, \"collection\": \"nyc_taxis\" } Parameter Default Description bulk-size 500 Number of documents per batch collection (first collection in workload) Target collection search Executes a Solr query and measures latency and throughput. { \"name\": \"match-all\", \"operatio..."},
{"title":"compare","url":"/solr-orbit/reference/commands/compare.html","content":"compare Compares results from two benchmark runs. Syntax solr-orbit compare --baseline BASELINE_ID --contender CONTENDER_ID Options Option Description --baseline Test execution ID of the baseline run --contender Test execution ID of the contender run --percentiles Comma-separated list of latency percentiles to report (e.g., 50,90,99,99.9) --results-format Output format: markdown (default) or csv --results-numbers-align Column alignment in the output table: right (default), left, center, or de..."},
{"title":"Concepts","url":"/solr-orbit/user-guide/concepts.html","content":"Concepts Workloads A workload is the central concept in Apache Solr Orbit. It defines: The data to load (corpora — compressed NDJSON files) The collections to create and configure The operations to run (bulk indexing, search queries, commits, etc.) The test procedures that sequence those operations Workloads are defined in a workload.json file. Pre-built workloads for Apache Solr are at https://github.com/apache/solr-orbit-workloads. Test Procedures A test procedure is a named configuration w..."},
{"title":"Configuring","url":"/solr-orbit/user-guide/install-and-configure/configuring.html","content":"Configuring Apache Solr Orbit Apache Solr Orbit stores its configuration in ~/.solr-orbit/benchmark.ini, which is automatically created the first time Solr Orbit runs. The file is divided into the following sections, which you can customize based on the needs of your environment. meta This section contains meta information about the configuration file. Parameter Type Description config.version Integer The version of the configuration file format. This value is managed by Solr Orbit and should..."},
{"title":"Sharing Custom Workloads","url":"/solr-orbit/user-guide/working-with-workloads/contributing-workloads.html","content":"Sharing Custom Workloads You can share a custom workload with other Apache Solr Orbit users by contributing it to the solr-orbit-workloads repository on GitHub — the default workload source for Apache Solr Orbit. Workloads in this repository are available to all users without needing --workload-path. For the full contribution guidelines — required files, README contents, data and licensing requirements, testing requirements, the pull request and review process, and the backporting policy — se..."},
{"title":"corpora","url":"/solr-orbit/reference/workloads/corpora.html","content":"corpora The \"corpora\" array defines the datasets to index. Each corpus references one or more document files. Syntax { \"corpora\": [ { \"name\": \"<corpus-name>\", \"documents\": [ { \"source-file\": \"<file>\", \"document-count\": <n>, \"compressed-bytes\": <bytes>, \"uncompressed-bytes\": <bytes>, \"target-collection\": \"<collection-name>\" } ] } ] } Fields Field Type Required Description name string Yes Corpus name, referenced from bulk-index operations. documents array Yes..."},
{"title":"create-workload","url":"/solr-orbit/reference/commands/create-workload.html","content":"create-workload Creates a new workload definition from data already indexed in a live Solr instance. Use this to capture a real dataset as a replayable workload corpus. Syntax solr-orbit create-workload --workload NAME --indices LIST --target-hosts HOSTS [OPTIONS] Options Option Short Required Default Description --workload -w Yes — Name for the generated workload --indices -i Yes — Comma-separated list of Solr collection (index) names to include --target-hosts -t Yes — Comma-separated host:p..."},
{"title":"Creating Custom Workloads","url":"/solr-orbit/user-guide/working-with-workloads/creating-custom-workloads.html","content":"Creating Custom Workloads To create a workload tailored for your Solr data and queries, create a directory with the structure described in Anatomy of a Workload. Minimal workload example my-benchmark/ ├── workload.json ├── configsets/ │ └── my_schema/ │ ├── schema.xml │ └── solrconfig.xml └── files/ └── my_data.json.gz workload.json: { \"description\": \"My custom Solr benchmark\", \"collections\": [ { \"name\": \"my_collection\", \"configset-path\": \"configsets/my_schema\", \"shards\": 1, \"nrt_replicas\": 1..."},
{"title":"download","url":"/solr-orbit/reference/commands/download.html","content":"download Downloads a Solr distribution to the local machine without running a benchmark. Use this to pre-fetch a distribution before running a from-distribution or docker pipeline benchmark. Syntax solr-orbit download --distribution-version VERSION [OPTIONS] Because Solr is pure Java, the distribution tarball is the same on every operating system and CPU architecture. There are no OS- or architecture-specific variants to select. Options Option Description --distribution-version Solr version t..."},
{"title":"FAQ","url":"/solr-orbit/faq.html","content":"Frequently Asked Questions What is Apache Solr Orbit? Apache Solr Orbit is a macro-benchmarking framework for Apache Solr clusters. It is a fork of OpenSearch Benchmark, adapted to work with Solr instead of OpenSearch. What Solr versions are supported? Apache Solr Orbit supports Solr 9.x and Solr 10.x. Some metrics collection endpoints differ between versions and are detected automatically at runtime. Where can I find pre-built workloads? Pre-built workloads for Apache Solr Orbit are availabl..."},
{"title":"Filesystem Metrics Store","url":"/solr-orbit/reference/metrics/filesystem-metrics-store.html","content":"Filesystem Metrics Store The filesystem metrics store is an opt-in extension of the default in-memory store. It keeps all metric records in RAM and additionally streams each metric document to a metrics.jsonl file on disk as the benchmark runs, making raw samples available for offline analysis even after the process exits. The default metrics store is in-memory. Enable the filesystem store explicitly when you need access to individual raw samples after the run. Configuration The store type is..."},
{"title":"Fine-tuning Workloads","url":"/solr-orbit/user-guide/working-with-workloads/finetune-workloads.html","content":"Fine-tuning Workloads Overriding parameters at runtime Workloads can expose Jinja2 parameters that you override at runtime with --workload-params. In workload.json (or an included operations file): { \"operation-type\": \"bulk-index\", \"bulk-size\": {{ bulk_size | default(500) }} } Override at runtime: solr-orbit run \\ --pipeline benchmark-only \\ --target-hosts localhost:8983 \\ --workload my-workload \\ --workload-params \"bulk_size:1000\" Multiple parameters are separated by commas. Parameter values..."},
{"title":"generate-data","url":"/solr-orbit/reference/commands/generate-data.html","content":"generate-data Generates synthetic benchmark data from an existing index schema (JSON mappings) or a custom Python module. The generated corpus can be used in Apache Solr Orbit workloads. Syntax solr-orbit generate-data --index-mappings FILE --total-size N --index-name NAME [OPTIONS] solr-orbit generate-data --custom-module FILE --total-size N --index-name NAME [OPTIONS] --index-mappings and --custom-module are mutually exclusive. --total-size is required. Options Option Short Required Default..."},
{"title":"Converter Tool","url":"/solr-orbit/converter/","content":"Converter Tool Apache Solr Orbit includes a convert-workload command that translates OpenSearch Benchmark workloads into Apache Solr Orbit format. The converter performs a best-effort translation. Most workloads require some manual review after conversion. Check the generated CONVERTED.md summary file for a list of items that may need attention. When to use the converter Use convert-workload when you want to run an existing OpenSearch Benchmark workload against Apache Solr. Pre-built Solr wor..."},
{"title":"Workload Reference","url":"/solr-orbit/reference/workloads/","content":"Workload Reference Complete reference for all workload.json keys and structures."},
{"title":"Metrics Reference","url":"/solr-orbit/reference/metrics/","content":"Metrics Apache Solr Orbit stores all metrics collected during a benchmark run so that they can be analyzed and compared across runs. This page describes the available storage options. Storing metrics Metrics can be stored in two ways depending on your analysis requirements. In memory (default) The default configuration keeps all metric records in RAM for the duration of the run. Results are computed from this in-memory state and written to test_run.json when the run completes. The raw individ..."},
{"title":"Command Reference","url":"/solr-orbit/reference/commands/","content":"Command Reference Reference documentation for all solr-orbit subcommands and their flags. Command Description aggregate Combine results from multiple benchmark runs compare Compare two benchmark runs side by side convert-workload Convert an OpenSearch Benchmark workload to Solr format create-workload Create a workload definition from an existing Solr collection download Download a Solr distribution without running a benchmark generate-data Generate synthetic data from an index schema or custo..."},
{"title":"Reference","url":"/solr-orbit/reference/","content":"Reference Complete reference documentation for Apache Solr Orbit commands, workload format, telemetry devices, result output, and metrics. Section Description Command Reference All solr-orbit subcommands and their flags Metrics Reference Metric keys, filesystem store layout, and raw data inspection"},
{"title":"Cluster Config","url":"/solr-orbit/cluster-config/","content":"Cluster Config The --cluster-config flag selects a preset JVM and garbage collector configuration applied to Solr nodes provisioned by Apache Solr Orbit. --cluster-config is only valid with provisioning pipelines: docker, from-distribution, and from-sources. It is not applicable to the benchmark-only pipeline, which connects to an already-running cluster without modifying it. Usage solr-orbit run \\ --pipeline docker \\ --distribution-version 9.10.1 \\ --workload nyc_taxis \\ --cluster-config 4gh..."},
{"title":"Understanding Workloads","url":"/solr-orbit/user-guide/understanding-workloads/","content":"Understanding Workloads A workload is the blueprint for a benchmark: it defines what data to load, what collections to create, and what operations to run."},
{"title":"Install and Configure","url":"/solr-orbit/user-guide/install-and-configure/","content":"Install and Configure This section covers installing Apache Solr Orbit and configuring it for your environment."},
{"title":"Optimizing Benchmarks","url":"/solr-orbit/user-guide/optimizing-benchmarks/","content":"Optimizing Benchmarks This section provides guidance for getting the most meaningful and reliable results from Apache Solr Orbit. Topic Description Target throughput Understand how target-throughput affects latency measurements and how to set it correctly Running distributed load Generate load from multiple machines to saturate large Solr clusters Performance testing best practices Methodology for repeatable, meaningful benchmark results Randomizing queries Vary query parameters across iterat..."},
{"title":"Working with Workloads","url":"/solr-orbit/user-guide/working-with-workloads/","content":"Working with Workloads This section covers how to run, create, and tune workloads for Apache Solr Orbit. Page Description Running a Workload How to invoke solr-orbit run with all common flags, pipelines, and options. Creating Custom Workloads Build a workload from scratch for your own Solr data and query patterns. Fine-tuning Workloads Override parameters and tune throughput, warmup, and concurrency for accurate results. Sharing Custom Workloads Guidelines for contributing a workload to the s..."},
{"title":"Understanding Results","url":"/solr-orbit/user-guide/understanding-results/","content":"Understanding Results How to read the benchmark output, interpret summary reports, and enable telemetry to collect JVM and Solr node metrics during a run."},
{"title":"User Guide","url":"/solr-orbit/user-guide/","content":"User Guide The User Guide covers the core concepts and workflows for using Apache Solr Orbit: from installation and configuration, through understanding the workload format, running benchmarks, and interpreting results. Section Description Concepts Core terminology: workloads, challenges, pipelines, collections, metrics Install and Configure Prerequisites, installation, and configuration file Understanding Workloads Workload anatomy, available workloads, built-in operations Working with Workl..."},
{"title":"Apache Solr Orbit","url":"/solr-orbit/","content":"Apache Solr Orbit Apache Solr Orbit is a performance benchmarking tool for Apache Solr clusters. Use Apache Solr Orbit to measure the performance of your Apache Solr clusters across a variety of workloads — from simple keyword queries to complex faceted search and aggregations. Getting started Quickstart — install the tool and run your first benchmark in minutes User Guide — deeper guides on workloads, pipelines, and results Reference — complete CLI and workload format reference Key features ..."},
{"title":"info","url":"/solr-orbit/reference/commands/info.html","content":"info Shows detailed information about a workload. Syntax solr-orbit info --workload WORKLOAD [OPTIONS] Options Option Description --workload Workload name (fetched from the workloads repository) --workload-path Path to a local workload directory --workload-repository Git URL for the workloads repository --workload-revision Git revision of the workloads repository --workload-params Comma-separated key:value Jinja2 parameter overrides --test-procedure Show details for a specific test procedure ..."},
{"title":"install","url":"/solr-orbit/reference/commands/install.html","content":"install Installs a local Solr node for use with the start and stop commands. This is a low-level provisioning command for when you want manual control over the Solr lifecycle rather than having run manage it automatically. Syntax solr-orbit install [OPTIONS] Options Distribution Option Default Description --distribution-version — Solr version to install (e.g., 9.10.1) --distribution-repository release Repository to download Solr from --revision — Source code revision for the from-sources pipe..."},
{"title":"Installing","url":"/solr-orbit/user-guide/install-and-configure/installing.html","content":"Installing Apache Solr Orbit You can install Apache Solr Orbit directly on a host running Linux or macOS. This page provides general hardware considerations and step-by-step installation instructions. Choosing appropriate hardware When selecting a host, consider which workloads you want to run. To see a list of available benchmark workloads, visit the solr-orbit-workloads repository on GitHub. Make sure that the Solr Orbit host has enough free storage space to store the compressed data corpus..."},
{"title":"list","url":"/solr-orbit/reference/commands/list.html","content":"list Lists available resources such as workloads and telemetry devices. Syntax solr-orbit list [RESOURCE] [OPTIONS] Resources Resource Description workloads List workloads from the configured workloads repository telemetry List available telemetry device names pipelines List available pipeline names test-runs List past benchmark runs with their IDs, timestamps, and metadata aggregated-results List past aggregated results cluster-configs List available cluster configuration presets Options Opt..."},
{"title":"Metric Records","url":"/solr-orbit/reference/metrics/metric-records.html","content":"Metric Records Apache Solr Orbit stores metrics as individual JSON documents. When the filesystem metrics store is active (the default), each document is appended as a single line to ~/.solr-orbit/benchmarks/test-runs/<run-id>/metrics.jsonl. The following example shows a single service_time record produced during a bulk-index operation on the nyc_taxis workload: { \"@timestamp\": 1691702842821, \"relative-time-ms\": 65.9, \"test-run-id\": \"8c43ee4c-cb34-494b-81b2-181be244f832\", \"test-run-time..."},
{"title":"Metric Keys","url":"/solr-orbit/reference/metrics/metrics-reference.html","content":"Metric Keys This page lists every metric key that Apache Solr Orbit can record. Metric keys appear in the name field of metric records. Metrics fall into two broad groups: Task-level metrics — recorded once per operation sample, tied to a specific workload task Telemetry metrics — recorded by background polling devices throughout the run, independent of any task Task-level metrics latency The time period between submitting a request and receiving the complete response, in milliseconds. Latenc..."},
{"title":"operations","url":"/solr-orbit/reference/workloads/operations.html","content":"operations Operations define the actions performed during a test procedure. They are referenced from test procedure schedules. Syntax Operations can be defined inline in a schedule or in a top-level \"operations\" section: { \"operations\": [ { \"name\": \"my-search\", \"operation-type\": \"search\", \"body\": { \"query\": \"*:*\", \"rows\": 10 } } ] } Built-in operation types bulk-index { \"operation-type\": \"bulk-index\", \"bulk-size\": 500, \"collection\": \"my_collection\" } Parameter Default Description bulk-size 50..."},
{"title":"Quickstart","url":"/solr-orbit/quickstart.html","content":"Apache Solr Orbit quickstart This page outlines how to quickly install Apache Solr Orbit and run your first benchmark workload. Prerequisites To perform the quickstart steps, you’ll need the following: Git 2.3 or later Python 3.12 or later An active Apache Solr cluster, or Docker (to let Solr Orbit start one for you) Set up a Solr cluster If you don’t already have a running Solr cluster, the easiest way to start one is with Docker: docker run -d --name solr-orbit -p 8983:8983 solr:9 solr-demo..."},
{"title":"Randomizing Queries","url":"/solr-orbit/user-guide/optimizing-benchmarks/randomizing-queries.html","content":"Randomizing Queries By default, a workload runs the same fixed queries on every iteration. This produces unrealistically optimistic latency numbers because Solr’s filter cache and query result cache will be warm after the first pass — subsequent identical queries hit the cache and complete much faster than they would in production. Randomizing queries generates varied parameter values across iterations, so each run exercises a realistic mix of cache hits and misses. How it works Apache Solr O..."},
{"title":"run","url":"/solr-orbit/reference/commands/run.html","content":"run Runs a benchmark workload. Syntax solr-orbit run [OPTIONS] Workload selection Option Description --workload Named workload from the workloads repository --workload-path Path to a local workload directory --workload-repository Git URL for the workloads repository (default: \"default\", resolved from benchmark.ini) --workload-revision Git revision (branch, tag, or commit) of the workloads repository; optional, uses the repository’s default branch if omitted --workload-params Override workload..."},
{"title":"Running Distributed Load","url":"/solr-orbit/user-guide/optimizing-benchmarks/running-distributed-load.html","content":"Running Distributed Load By default, Apache Solr Orbit generates all load from the machine where you run the solr-orbit command. For large clusters or high-throughput benchmarks, a single machine may become the bottleneck before Solr does. Distributed load generation lets you spread the workload across multiple machines. Architecture In distributed mode, one machine acts as the coordinator and one or more additional machines act as workers. The coordinator: Parses and distributes the workload..."},
{"title":"Running a Workload","url":"/solr-orbit/user-guide/working-with-workloads/running-workloads.html","content":"Running a Workload Listing available workloads To see which named workloads are available in the configured workload repository: solr-orbit list workloads This prints the name and description of each workload that Solr Orbit can fetch and run by name. Workloads are fetched from the repository configured under [workloads] in ~/.solr-orbit/benchmark.ini (default: https://github.com/apache/solr-orbit-workloads). Basic syntax solr-orbit run [--pipeline PIPELINE] [--target-hosts HOSTS] \\ [--worklo..."},
{"title":"start","url":"/solr-orbit/reference/commands/start.html","content":"# start Starts a locally installed Solr node previously created by the [`install`](install.html) command. ## Syntax ```bash solr-orbit start --installation-id ID --test-run-id ID [OPTIONS] ``` ## Options | Option | Required | Description | |--------|----------|-------------| | `--installation-id` | Yes | ID of the installation to start (returned by the `install` command) | | `--test-run-id` | Yes | Test run ID to associate with this start event | | `--runtime-jdk` | No | Major JDK version to ..."},
{"title":"stop","url":"/solr-orbit/reference/commands/stop.html","content":"# stop Stops a locally running Solr node that was started with the [`start`](start.html) command. ## Syntax ```bash solr-orbit stop --installation-id ID [OPTIONS] ``` ## Options | Option | Required | Default | Description | |--------|----------|---------|-------------| | `--installation-id` | Yes | — | ID of the installation to stop | | `--preserve-install` | No | off | Keep the installation files on disk after stopping. By default, the installation directory is deleted when the node stops | ..."},
{"title":"Summary Report Format","url":"/solr-orbit/reference/summary-report.html","content":"# Summary Report Format Apache Solr Orbit saves results in JSON and CSV format to `~/.solr-orbit/benchmarks/test-runs//`. ## JSON format The `results.json` file contains an array of metric objects, one per recorded metric per task: ```json [ { \"task\": \"bulk-index\", \"operation\": \"bulk-index\", \"throughput\": { \"mean\": 4500.0, \"unit\": \"docs/s\" }, \"latency\": { \"50\": 12.3, \"90\": 18.7, \"99\": 25.1, \"99.9\": 32.4, \"unit\": \"ms\" }, \"error_rate\": 0.0, \"duration\": 120.5 }, { \"task\": \"search\", \"operation\": ..."},
{"title":"Summary Reports","url":"/solr-orbit/user-guide/understanding-results/summary-reports.html","content":"# Understanding the Summary Report At the end of each test run, Apache Solr Orbit prints a summary report to the console and saves the results to disk. The report shows metrics such as throughput, latency, service time, and error rate for each task in the challenge. ## Console output The summary table is printed after all tasks complete. The following is a real example from a `nyc_taxis` workload run in `--test-mode` against Apache Solr 9.10.1: ``` --------------------------------------------..."},
{"title":"Target Throughput","url":"/solr-orbit/user-guide/optimizing-benchmarks/target-throughput.html","content":"# Target Throughput `target-throughput` is one of the most important — and most misunderstood — parameters in Apache Solr Orbit. Getting it right is key to measuring meaningful latency. ## What target-throughput means `target-throughput` sets the rate at which Apache Solr Orbit issues requests, measured in operations per second (ops/s). It does **not** guarantee that Solr will complete requests at that rate — it only controls how fast the benchmark sends them. ## Two benchmark modes ### Pure ..."},
{"title":"Telemetry Devices","url":"/solr-orbit/reference/telemetry.html","content":"# Telemetry Devices Apache Solr Orbit includes telemetry devices for collecting server-side metrics. Six devices are **always enabled** and collect metrics automatically without any flags. One additional device (`disk-io`) runs automatically on provisioned pipelines. Eight further devices can be enabled on demand with `--telemetry`. Both Solr 9.x (JSON format) and Solr 10.x (Prometheus text format) are supported. Format detection is automatic via the HTTP `Content-Type` header. --- ## solr-jv..."},
{"title":"Enabling Telemetry","url":"/solr-orbit/user-guide/understanding-results/telemetry.html","content":"# Enabling Telemetry Apache Solr Orbit can collect server-side metrics from your Solr cluster during a benchmark run using *telemetry devices*. Devices are split into two groups: - **Always-enabled devices** — active on every run, no flag needed. - **Optional devices** — enabled on demand with `--telemetry `. ## Always-enabled devices These six devices are active on every benchmark run: | Device | Description | |--------|-------------| | `solr-jvm-stats` | JVM heap, GC pause times, GC counts,..."},
{"title":"test-procedures","url":"/solr-orbit/reference/workloads/test-procedures.html","content":"# test-procedures Test procedures define named benchmark scenarios within a workload. A workload typically defines one or more test procedures, each specifying a schedule of operations. ## Syntax ```json { \"test-procedures\": [ { \"name\": \"append-no-conflicts\", \"description\": \"Index all documents then run searches\", \"default\": true, \"schedule\": [ { \"operation\": \"bulk-index\", \"warmup-time-period\": 120, \"clients\": 8 }, { \"operation\": \"commit\" }, { \"operation\": \"search\", \"clients\": 1, \"iterations\"..."},
{"title":"Usage","url":"/solr-orbit/converter/usage.html","content":"# Using the Converter ## Basic usage ```bash solr-orbit convert-workload \\ --workload-path /path/to/osb-workload \\ --output-path /path/to/solr-workload ``` ## Options | Option | Description | |--------|-------------| | `--workload-path` | Path to the source OpenSearch Benchmark workload directory | | `--output-path` | Destination directory for the converted workload | | `--force` | Overwrite the output directory if it already exists | ## Output The converter produces a copy of the workload in..."},
{"title":"visualize","url":"/solr-orbit/reference/commands/visualize.html","content":"# visualize Generates an interactive HTML visualization for a completed benchmark run. The output file can be opened in any web browser to explore metric trends, throughput charts, and latency distributions. ## Syntax ```bash solr-orbit visualize --test-run-id ID [OPTIONS] ``` ## Options | Option | Short | Required | Default | Description | |--------|-------|----------|---------|-------------| | `--test-run-id` | `-tid` | Yes | — | ID of the completed test run to visualize (see `solr-orbit li..."},
{"title":"What Gets Converted","url":"/solr-orbit/converter/what-converts.html","content":"# What Gets Converted The table below summarizes which OpenSearch Benchmark constructs are automatically converted, which require manual review, and which are skipped with a TODO comment. ## Automatically converted | Construct | Conversion | |-----------|------------| | `\"indices\"` key in workload.json | Renamed to `\"collections\"` | | `create-index` operation type | → `create-collection` | | `delete-index` operation type | → `delete-collection` | | Simple `match` queries | Converted to Solr J..."}
]