Full Code of quickwit-oss/quickwit for AI

gitextract_hf8mrikh/

├── .cargo/
│   └── config.toml
├── .claude/
│   └── skills/
│       ├── bump-tantivy/
│       │   └── SKILL.md
│       ├── fix-clippy/
│       │   └── SKILL.md
│       ├── fmt/
│       │   └── SKILL.md
│       ├── rationalize-deps/
│       │   └── SKILL.md
│       └── simple-pr/
│           └── SKILL.md
├── .devcontainer/
│   ├── devcontainer.json
│   ├── post-create.sh
│   └── welcome.txt
├── .dockerignore
├── .gitattributes
├── .github/
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug_report.md
│   │   ├── documentation_request.md
│   │   ├── feature_request.md
│   │   └── tutorial_request.md
│   ├── PULL_REQUEST_TEMPLATE.md
│   ├── actions/
│   │   ├── cargo-build-macos-binary/
│   │   │   └── action.yml
│   │   └── cross-build-binary/
│   │       └── action.yml
│   ├── dependabot.yml
│   └── workflows/
│       ├── ci.yml
│       ├── coverage.yml
│       ├── dependency.yml
│       ├── publish_cross_images.yml
│       ├── publish_docker_images.yml
│       ├── publish_lambda.yaml
│       ├── publish_nightly_packages.yml
│       ├── publish_release_packages.yml
│       ├── requirements.txt
│       ├── scorecard.yml
│       └── ui-ci.yml
├── .gitignore
├── .localstack/
│   └── init.sh
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CODE_STYLE.md
├── CONTRIBUTING.md
├── Dockerfile
├── LICENSE
├── LICENSE-3rdparty.csv
├── Makefile
├── README.md
├── SECURITY.md
├── _typos.toml
├── build/
│   └── cross-images/
│       ├── aarch64-unknown-linux-gnu.dockerfile
│       ├── aarch64-unknown-linux-musl.dockerfile
│       ├── x86_64-unknown-linux-gnu.dockerfile
│       └── x86_64-unknown-linux-musl.dockerfile
├── config/
│   ├── quickwit.yaml
│   ├── templates/
│   │   ├── gh-archive.yaml
│   │   └── stackoverflow.yaml
│   └── tutorials/
│       ├── fluentbit-logs/
│       │   └── index-config.yaml
│       ├── gh-archive/
│       │   ├── index-config-for-clickhouse.yaml
│       │   ├── index-config.yaml
│       │   ├── kafka-source.yaml
│       │   └── kinesis-source.yaml
│       ├── grafana/
│       │   └── docker-compose.yml
│       ├── hdfs-logs/
│       │   ├── index-config-partitioned.yaml
│       │   ├── index-config-retention-policy.yaml
│       │   ├── index-config.yaml
│       │   ├── searcher-1.yaml
│       │   ├── searcher-2.yaml
│       │   └── searcher-3.yaml
│       ├── otel-logs/
│       │   ├── index-config.yaml
│       │   ├── kafka-source.yaml
│       │   └── otel-values.yaml
│       ├── otel-traces/
│       │   ├── index-config.yaml
│       │   └── kafka-source.yaml
│       ├── stackoverflow/
│       │   ├── index-config.yaml
│       │   ├── pulsar-source.yaml
│       │   └── send_messages_to_pulsar.py
│       ├── vector-otel-logs/
│       │   └── vector.toml
│       └── wikipedia/
│           ├── index-config.yaml
│           └── multilang-index-config.yaml
├── distribution/
│   ├── docker/
│   │   └── ubuntu/
│   │       └── Dockerfile
│   ├── ecs/
│   │   ├── .gitignore
│   │   ├── README.md
│   │   ├── example/
│   │   │   ├── .terraform.lock.hcl
│   │   │   ├── bastion.tf
│   │   │   ├── image.tf
│   │   │   ├── kafka.tf
│   │   │   ├── terraform.tf
│   │   │   └── vpc.tf
│   │   └── quickwit/
│   │       ├── cluster.tf
│   │       ├── configs.tf
│   │       ├── iam.tf
│   │       ├── outputs.tf
│   │       ├── quickwit-control-plane.tf
│   │       ├── quickwit-indexer.tf
│   │       ├── quickwit-janitor.tf
│   │       ├── quickwit-metastore.tf
│   │       ├── quickwit-searcher.tf
│   │       ├── rds.tf
│   │       ├── s3.tf
│   │       ├── service/
│   │       │   ├── config.tf
│   │       │   ├── ecs.tf
│   │       │   └── variables.tf
│   │       └── variables.tf
│   └── kubernetes/
│       └── README.md
├── docker-compose.yml
├── docs/
│   ├── assets/
│   │   └── sqs-file-source.tf
│   ├── configuration/
│   │   ├── _category_.yaml
│   │   ├── index-config.md
│   │   ├── index.md
│   │   ├── lambda-config.md
│   │   ├── metastore-config.md
│   │   ├── node-config.md
│   │   ├── ports-config.md
│   │   ├── source-config.md
│   │   ├── storage-config.md
│   │   └── template-config.md
│   ├── deployment/
│   │   ├── _category_.yaml
│   │   ├── cluster-sizing.md
│   │   ├── deployment-modes.md
│   │   └── kubernetes/
│   │       ├── _category_.yaml
│   │       ├── gke.md
│   │       ├── glasskube.md
│   │       └── helm.md
│   ├── distributed-tracing/
│   │   ├── _category_.yaml
│   │   ├── otel-service.md
│   │   ├── overview.md
│   │   ├── plug-quickwit-to-jaeger.md
│   │   └── send-traces/
│   │       ├── _category_.yaml
│   │       ├── using-otel-collector.md
│   │       └── using-otel-sdk-python.md
│   ├── get-started/
│   │   ├── _category_.yaml
│   │   ├── installation.md
│   │   ├── query-language-intro.md
│   │   ├── quickstart.md
│   │   └── tutorials/
│   │       ├── _category_.yaml
│   │       ├── prometheus-metrics.md
│   │       ├── trace-analytics-with-grafana.md
│   │       ├── tutorial-hdfs-logs-distributed-search-aws-s3.md
│   │       ├── tutorial-hdfs-logs.md
│   │       └── tutorial-jaeger.md
│   ├── guides/
│   │   ├── _category_.yaml
│   │   ├── aws-setup.md
│   │   ├── schemaless.md
│   │   └── storage-setup/
│   │       ├── _category_.yaml
│   │       └── aws-s3.md
│   ├── ingest-data/
│   │   ├── _category_.yaml
│   │   ├── index.md
│   │   ├── ingest-api.md
│   │   ├── ingest-local-file.md
│   │   ├── kafka.md
│   │   ├── kinesis.md
│   │   ├── pulsar.md
│   │   └── sqs-files.md
│   ├── internals/
│   │   ├── backward-compatibility.md
│   │   ├── date-time.md
│   │   ├── ingest-v2.md
│   │   ├── scroll.md
│   │   ├── searcher-split-cache.md
│   │   ├── sorting.md
│   │   ├── split-format.md
│   │   └── template-index.md
│   ├── log-management/
│   │   ├── _category_.yaml
│   │   ├── otel-service.md
│   │   ├── overview.md
│   │   ├── send-logs/
│   │   │   ├── _category_.yaml
│   │   │   ├── send-docker-logs.md
│   │   │   ├── using-fluentbit.md
│   │   │   ├── using-otel-collector-with-helm.md
│   │   │   ├── using-otel-collector.md
│   │   │   └── using-vector.md
│   │   └── supported-agents.md
│   ├── operating/
│   │   ├── _category_.yaml
│   │   ├── aws-costs.md
│   │   ├── data-directory.md
│   │   ├── monitoring.md
│   │   └── upgrades.md
│   ├── overview/
│   │   ├── _category_.yaml
│   │   ├── architecture.md
│   │   ├── concepts/
│   │   │   ├── _category_.yaml
│   │   │   ├── deletes.md
│   │   │   ├── indexing.md
│   │   │   └── querying.md
│   │   ├── index.md
│   │   └── introduction.md
│   ├── reference/
│   │   ├── _category_.yaml
│   │   ├── aggregation.md
│   │   ├── cli.md
│   │   ├── es_compatible_api.md
│   │   ├── metrics.md
│   │   ├── query-language.md
│   │   ├── rest-api.md
│   │   └── updating-mapper.md
│   └── telemetry.md
├── install.sh
├── monitoring/
│   ├── grafana/
│   │   ├── README.md
│   │   ├── dashboards/
│   │   │   ├── indexers.json
│   │   │   ├── ingesters.json
│   │   │   ├── metastore.json
│   │   │   └── searchers.json
│   │   └── provisioning/
│   │       ├── dashboards/
│   │       │   └── default.yaml
│   │       └── datasources/
│   │           └── default.yaml
│   ├── otel-collector-config.yaml
│   └── prometheus.yaml
└── quickwit/
    ├── .cargo/
    │   └── config.toml
    ├── .cargo-dev/
    │   └── config.toml
    ├── .config/
    │   └── nextest.toml
    ├── .license_header.txt
    ├── CLAUDE.md
    ├── Cargo.toml
    ├── Cross.toml
    ├── Makefile
    ├── NOTICE
    ├── clippy.toml
    ├── deny.toml
    ├── dependency-licenses.html
    ├── license-tool.toml
    ├── quickwit-actors/
    │   ├── Cargo.toml
    │   ├── LICENSE
    │   ├── README.md
    │   ├── benches/
    │   │   └── bench.rs
    │   ├── examples/
    │   │   └── ping_actor.rs
    │   └── src/
    │       ├── actor.rs
    │       ├── actor_context.rs
    │       ├── actor_handle.rs
    │       ├── actor_state.rs
    │       ├── channel_with_priority.rs
    │       ├── command.rs
    │       ├── envelope.rs
    │       ├── lib.rs
    │       ├── mailbox.rs
    │       ├── observation.rs
    │       ├── registry.rs
    │       ├── scheduler.rs
    │       ├── spawn_builder.rs
    │       ├── supervisor.rs
    │       ├── tests.rs
    │       └── universe.rs
    ├── quickwit-aws/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── error.rs
    │       ├── lib.rs
    │       └── retry.rs
    ├── quickwit-cli/
    │   ├── Cargo.toml
    │   ├── src/
    │   │   ├── checklist.rs
    │   │   ├── cli.rs
    │   │   ├── cli_doc_ext.toml
    │   │   ├── generate_markdown.rs
    │   │   ├── index.rs
    │   │   ├── jemalloc.rs
    │   │   ├── lib.rs
    │   │   ├── logger.rs
    │   │   ├── main.rs
    │   │   ├── metrics.rs
    │   │   ├── service.rs
    │   │   ├── source.rs
    │   │   ├── split.rs
    │   │   ├── stats.rs
    │   │   └── tool.rs
    │   └── tests/
    │       ├── Pipfile
    │       ├── cli.rs
    │       ├── helpers.rs
    │       └── prepare_tests.sh
    ├── quickwit-cluster/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── change.rs
    │       ├── cluster.rs
    │       ├── grpc_gossip.rs
    │       ├── grpc_service.rs
    │       ├── lib.rs
    │       ├── member.rs
    │       ├── metrics.rs
    │       └── node.rs
    ├── quickwit-codegen/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── example/
    │   │   ├── Cargo.toml
    │   │   ├── build.rs
    │   │   └── src/
    │   │       ├── codegen/
    │   │       │   └── hello.rs
    │   │       ├── error.rs
    │   │       ├── hello.proto
    │   │       └── lib.rs
    │   └── src/
    │       ├── codegen.rs
    │       └── lib.rs
    ├── quickwit-common/
    │   ├── Cargo.toml
    │   ├── build.rs
    │   └── src/
    │       ├── alloc_tracker.rs
    │       ├── binary_heap.rs
    │       ├── coolid.rs
    │       ├── cpus.rs
    │       ├── fs.rs
    │       ├── io.rs
    │       ├── jemalloc_profiled.rs
    │       ├── kill_switch.rs
    │       ├── lib.rs
    │       ├── metrics.rs
    │       ├── net.rs
    │       ├── path_hasher.rs
    │       ├── pretty.rs
    │       ├── progress.rs
    │       ├── pubsub.rs
    │       ├── rand.rs
    │       ├── rate_limited_tracing.rs
    │       ├── rate_limiter.rs
    │       ├── rendezvous_hasher.rs
    │       ├── retry.rs
    │       ├── ring_buffer.rs
    │       ├── runtimes.rs
    │       ├── shared_consts.rs
    │       ├── socket_addr_legacy_hash.rs
    │       ├── sorted_iter.rs
    │       ├── stream_utils.rs
    │       ├── temp_dir.rs
    │       ├── test_utils.rs
    │       ├── thread_pool.rs
    │       ├── tower/
    │       │   ├── box_layer.rs
    │       │   ├── box_service.rs
    │       │   ├── buffer.rs
    │       │   ├── change.rs
    │       │   ├── circuit_breaker.rs
    │       │   ├── delay.rs
    │       │   ├── estimate_rate.rs
    │       │   ├── event_listener.rs
    │       │   ├── load_shed.rs
    │       │   ├── metrics.rs
    │       │   ├── mod.rs
    │       │   ├── one_task_per_call_layer.rs
    │       │   ├── pool.rs
    │       │   ├── rate.rs
    │       │   ├── rate_estimator.rs
    │       │   ├── rate_limit.rs
    │       │   ├── retry.rs
    │       │   ├── timeout.rs
    │       │   └── transport.rs
    │       ├── type_map.rs
    │       └── uri.rs
    ├── quickwit-config/
    │   ├── Cargo.toml
    │   ├── resources/
    │   │   └── tests/
    │   │       ├── index_config/
    │   │       │   ├── hdfs-logs-create-config.yaml
    │   │       │   ├── hdfs-logs.json
    │   │       │   ├── hdfs-logs.toml
    │   │       │   ├── hdfs-logs.yaml
    │   │       │   ├── minimal-hdfs-logs.yaml
    │   │       │   └── partial-hdfs-logs.yaml
    │   │       ├── node_config/
    │   │       │   ├── quickwit.json
    │   │       │   ├── quickwit.toml
    │   │       │   ├── quickwit.wrongkey.yaml
    │   │       │   └── quickwit.yaml
    │   │       └── source_config/
    │   │           ├── ingest-api-source.json
    │   │           ├── kafka-source.json
    │   │           └── kinesis-source.yaml
    │   └── src/
    │       ├── cluster_config/
    │       │   └── mod.rs
    │       ├── config_value.rs
    │       ├── index_config/
    │       │   ├── mod.rs
    │       │   └── serialize.rs
    │       ├── index_template/
    │       │   ├── mod.rs
    │       │   └── serialize.rs
    │       ├── lib.rs
    │       ├── merge_policy_config.rs
    │       ├── metastore_config.rs
    │       ├── node_config/
    │       │   ├── mod.rs
    │       │   └── serialize.rs
    │       ├── qw_env_vars.rs
    │       ├── serde_utils.rs
    │       ├── service.rs
    │       ├── source_config/
    │       │   ├── mod.rs
    │       │   └── serialize.rs
    │       ├── storage_config.rs
    │       └── templating.rs
    ├── quickwit-control-plane/
    │   ├── Cargo.toml
    │   ├── README.md
    │   └── src/
    │       ├── control_plane.rs
    │       ├── cooldown_map.rs
    │       ├── debouncer.rs
    │       ├── indexing_plan.rs
    │       ├── indexing_scheduler/
    │       │   ├── change_tracker.rs
    │       │   ├── mod.rs
    │       │   └── scheduling/
    │       │       ├── README.md
    │       │       ├── mod.rs
    │       │       ├── scheduling_logic.rs
    │       │       └── scheduling_logic_model.rs
    │       ├── ingest/
    │       │   ├── ingest_controller.rs
    │       │   ├── mod.rs
    │       │   ├── scaling_arbiter.rs
    │       │   └── wait_handle.rs
    │       ├── lib.rs
    │       ├── metrics.rs
    │       ├── model/
    │       │   ├── mod.rs
    │       │   └── shard_table.rs
    │       └── tests.rs
    ├── quickwit-datetime/
    │   ├── Cargo.toml
    │   ├── README.md
    │   └── src/
    │       ├── date_time_format.rs
    │       ├── date_time_parsing.rs
    │       ├── java_date_time_format.rs
    │       └── lib.rs
    ├── quickwit-directories/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── bundle_directory.rs
    │       ├── caching_directory.rs
    │       ├── debug_proxy_directory.rs
    │       ├── hot_directory.rs
    │       ├── lib.rs
    │       ├── storage_directory.rs
    │       └── union_directory.rs
    ├── quickwit-doc-mapper/
    │   ├── Cargo.toml
    │   ├── benches/
    │   │   ├── data/
    │   │   │   ├── simple-parse-bench.json
    │   │   │   └── simple-routing-expression-bench.json
    │   │   ├── doc_to_json_bench.rs
    │   │   └── routing_expression_bench.rs
    │   └── src/
    │       ├── doc_mapper/
    │       │   ├── date_time_type.rs
    │       │   ├── doc_mapper_builder.rs
    │       │   ├── doc_mapper_impl.rs
    │       │   ├── field_mapping_entry.rs
    │       │   ├── field_mapping_type.rs
    │       │   ├── field_presence.rs
    │       │   ├── mapping_tree.rs
    │       │   ├── mod.rs
    │       │   ├── tantivy_val_to_json.rs
    │       │   └── tokenizer_entry.rs
    │       ├── doc_mapping.rs
    │       ├── error.rs
    │       ├── lib.rs
    │       ├── query_builder.rs
    │       ├── routing_expression/
    │       │   └── mod.rs
    │       └── tag_pruning.rs
    ├── quickwit-index-management/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── garbage_collection.rs
    │       ├── index.rs
    │       └── lib.rs
    ├── quickwit-indexing/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── benches/
    │   │   ├── data/
    │   │   │   ├── bench_data.json
    │   │   │   ├── bench_data_heavy_transform.json
    │   │   │   └── bench_data_light_transform.json
    │   │   └── doc_process_vrl_bench.rs
    │   ├── data/
    │   │   └── test_corpus.json
    │   ├── failpoints/
    │   │   └── mod.rs
    │   └── src/
    │       ├── actors/
    │       │   ├── cooperative_indexing.rs
    │       │   ├── doc_processor.rs
    │       │   ├── index_serializer.rs
    │       │   ├── indexer.rs
    │       │   ├── indexing_pipeline.rs
    │       │   ├── indexing_service.rs
    │       │   ├── merge_executor.rs
    │       │   ├── merge_pipeline.rs
    │       │   ├── merge_planner.rs
    │       │   ├── merge_scheduler_service.rs
    │       │   ├── merge_split_downloader.rs
    │       │   ├── mod.rs
    │       │   ├── packager.rs
    │       │   ├── publisher.rs
    │       │   ├── sequencer.rs
    │       │   ├── uploader.rs
    │       │   └── vrl_processing.rs
    │       ├── controlled_directory.rs
    │       ├── lib.rs
    │       ├── merge_policy/
    │       │   ├── const_write_amplification.rs
    │       │   ├── mod.rs
    │       │   ├── nop_merge_policy.rs
    │       │   └── stable_log_merge_policy.rs
    │       ├── metrics.rs
    │       ├── models/
    │       │   ├── indexed_split.rs
    │       │   ├── indexing_service_message.rs
    │       │   ├── indexing_statistics.rs
    │       │   ├── merge_planner_message.rs
    │       │   ├── merge_scratch.rs
    │       │   ├── merge_statistics.rs
    │       │   ├── mod.rs
    │       │   ├── packaged_split.rs
    │       │   ├── processed_doc.rs
    │       │   ├── publish_lock.rs
    │       │   ├── publisher_message.rs
    │       │   ├── raw_doc_batch.rs
    │       │   ├── shard_positions.rs
    │       │   └── split_attrs.rs
    │       ├── source/
    │       │   ├── doc_file_reader.rs
    │       │   ├── file_source.rs
    │       │   ├── gcp_pubsub_source.rs
    │       │   ├── ingest/
    │       │   │   └── mod.rs
    │       │   ├── ingest_api_source.rs
    │       │   ├── kafka_source.rs
    │       │   ├── kinesis/
    │       │   │   ├── api.rs
    │       │   │   ├── helpers.rs
    │       │   │   ├── kinesis_source.rs
    │       │   │   ├── mod.rs
    │       │   │   └── shard_consumer.rs
    │       │   ├── mod.rs
    │       │   ├── pulsar_source.rs
    │       │   ├── queue_sources/
    │       │   │   ├── coordinator.rs
    │       │   │   ├── design.md
    │       │   │   ├── helpers.rs
    │       │   │   ├── local_state.rs
    │       │   │   ├── memory_queue.rs
    │       │   │   ├── message.rs
    │       │   │   ├── mod.rs
    │       │   │   ├── shared_state.rs
    │       │   │   ├── sqs_queue.rs
    │       │   │   └── visibility.rs
    │       │   ├── source_factory.rs
    │       │   ├── stdin_source.rs
    │       │   ├── vec_source.rs
    │       │   └── void_source.rs
    │       ├── split_store/
    │       │   ├── indexing_split_cache.rs
    │       │   ├── indexing_split_store.rs
    │       │   ├── mod.rs
    │       │   └── split_store_quota.rs
    │       └── test_utils.rs
    ├── quickwit-ingest/
    │   ├── Cargo.toml
    │   ├── build.rs
    │   └── src/
    │       ├── codegen/
    │       │   └── ingest_service.rs
    │       ├── doc_batch.rs
    │       ├── error.rs
    │       ├── ingest_api_service.rs
    │       ├── ingest_service.proto
    │       ├── ingest_v2/
    │       │   ├── broadcast/
    │       │   │   ├── capacity_score.rs
    │       │   │   ├── local_shards.rs
    │       │   │   └── mod.rs
    │       │   ├── debouncing.rs
    │       │   ├── doc_mapper.rs
    │       │   ├── fetch.rs
    │       │   ├── helpers.rs
    │       │   ├── idle.rs
    │       │   ├── ingest.md
    │       │   ├── ingester.rs
    │       │   ├── metrics.rs
    │       │   ├── mod.rs
    │       │   ├── models.rs
    │       │   ├── mrecord.rs
    │       │   ├── mrecordlog_utils.rs
    │       │   ├── publish_tracker.rs
    │       │   ├── rate_meter.rs
    │       │   ├── replication.md
    │       │   ├── replication.rs
    │       │   ├── router.rs
    │       │   ├── routing_table.rs
    │       │   ├── state.rs
    │       │   ├── wal_capacity_tracker.rs
    │       │   └── workbench.rs
    │       ├── lib.rs
    │       ├── memory_capacity.rs
    │       ├── metrics.rs
    │       ├── mrecordlog_async.rs
    │       ├── notifications.rs
    │       ├── position.rs
    │       └── queue.rs
    ├── quickwit-integration-tests/
    │   ├── Cargo.toml
    │   ├── src/
    │   │   ├── lib.rs
    │   │   ├── test_utils/
    │   │   │   ├── cluster_sandbox.rs
    │   │   │   ├── mod.rs
    │   │   │   └── shutdown.rs
    │   │   └── tests/
    │   │       ├── basic_tests.rs
    │   │       ├── ingest_v1_tests.rs
    │   │       ├── ingest_v2_tests.rs
    │   │       ├── mod.rs
    │   │       ├── no_cp_tests.rs
    │   │       ├── otlp_tests.rs
    │   │       ├── sqs_tests.rs
    │   │       ├── tls_tests.rs
    │   │       └── update_tests/
    │   │           ├── create_on_update.rs
    │   │           ├── doc_mapping_tests.rs
    │   │           ├── mod.rs
    │   │           ├── restart_indexer_tests.rs
    │   │           └── search_settings_tests.rs
    │   └── test_data/
    │       ├── README.md
    │       ├── ca.crt
    │       ├── ca.key
    │       ├── ca.srl
    │       ├── regenerate-certs.sh
    │       ├── server.crt
    │       ├── server.csr
    │       ├── server.key
    │       └── server.v3.ext
    ├── quickwit-jaeger/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── lib.rs
    │       ├── metrics.rs
    │       ├── v1.rs
    │       └── v2.rs
    ├── quickwit-janitor/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── actors/
    │       │   ├── delete_task_pipeline.rs
    │       │   ├── delete_task_planner.rs
    │       │   ├── delete_task_service.rs
    │       │   ├── garbage_collector.rs
    │       │   ├── mod.rs
    │       │   └── retention_policy_executor.rs
    │       ├── error.rs
    │       ├── janitor_service.rs
    │       ├── lib.rs
    │       ├── metrics.rs
    │       └── retention_policy_execution.rs
    ├── quickwit-lambda-client/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── build.rs
    │   └── src/
    │       ├── deploy.rs
    │       ├── invoker.rs
    │       ├── lib.rs
    │       └── metrics.rs
    ├── quickwit-lambda-server/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── bin/
    │       │   └── leaf_search.rs
    │       ├── context.rs
    │       ├── error.rs
    │       ├── handler.rs
    │       └── lib.rs
    ├── quickwit-macros/
    │   ├── Cargo.toml
    │   └── src/
    │       └── lib.rs
    ├── quickwit-metastore/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── build.rs
    │   ├── migrations/
    │   │   └── postgresql/
    │   │       ├── 10_add-split-incarnation-id.down.sql
    │   │       ├── 10_add-split-incarnation-id.up.sql
    │   │       ├── 11_add-split-maturity-timestamp-field.down.sql
    │   │       ├── 11_add-split-maturity-timestamp-field.up.sql
    │   │       ├── 12_create-shards.down.sql
    │   │       ├── 12_create-shards.up.sql
    │   │       ├── 13_migrate-otel-indexes-v0_6.down.sql
    │   │       ├── 13_migrate-otel-indexes-v0_6.up.sql
    │   │       ├── 14_update-shard-id.down.sql
    │   │       ├── 14_update-shard-id.up.sql
    │   │       ├── 15_create-templates.down.sql
    │   │       ├── 15_create-templates.up.sql
    │   │       ├── 16_create-index-split-uid.down.sql
    │   │       ├── 16_create-index-split-uid.up.sql
    │   │       ├── 17_create-index-split-timestamp.down.sql
    │   │       ├── 17_create-index-split-timestamp.up.sql
    │   │       ├── 18_create-index-shard-index-uid.down.sql
    │   │       ├── 18_create-index-shard-index-uid.up.sql
    │   │       ├── 19_add-split-node-id-field.down.sql
    │   │       ├── 19_add-split-node-id-field.up.sql
    │   │       ├── 1_create-indexes.down.sql
    │   │       ├── 1_create-indexes.up.sql
    │   │       ├── 20_add-shard-doc-mapping-uid-field.down.sql
    │   │       ├── 20_add-shard-doc-mapping-uid-field.up.sql
    │   │       ├── 21_add-shard-update-timestamp-field.down.sql
    │   │       ├── 21_add-shard-update-timestamp-field.up.sql
    │   │       ├── 22_change-splits-pkey.down.sql
    │   │       ├── 22_change-splits-pkey.up.sql
    │   │       ├── 23_change-indexes-unique-index.down.sql
    │   │       ├── 23_change-indexes-unique-index.up.sql
    │   │       ├── 24_add-arbitrary-kv.down.sql
    │   │       ├── 24_add-arbitrary-kv.up.sql
    │   │       ├── 25_add-split-size.down.sql
    │   │       ├── 25_add-split-size.up.sql
    │   │       ├── 2_create-splits.down.sql
    │   │       ├── 2_create-splits.up.sql
    │   │       ├── 3_add-split-publish-timestamp-field.down.sql
    │   │       ├── 3_add-split-publish-timestamp-field.up.sql
    │   │       ├── 4_create-delete_tasks.down.sql
    │   │       ├── 4_create-delete_tasks.up.sql
    │   │       ├── 5_add-delete-opstamp-splits.down.sql
    │   │       ├── 5_add-delete-opstamp-splits.up.sql
    │   │       ├── 6_delete-update-index-update-timestamp-on-split-update-trigger.up.sql
    │   │       ├── 7_delete-split-table-triggers.up.sql
    │   │       ├── 8_delete-update-timestamp-on-indexes-table.up.sql
    │   │       ├── 9_add-split-incarnation-id.down.sql
    │   │       └── 9_add-split-incarnation-id.up.sql
    │   ├── src/
    │   │   ├── backward_compatibility_tests/
    │   │   │   ├── README.md
    │   │   │   └── mod.rs
    │   │   ├── checkpoint.rs
    │   │   ├── error.rs
    │   │   ├── lib.rs
    │   │   ├── metastore/
    │   │   │   ├── control_plane_metastore.rs
    │   │   │   ├── file_backed/
    │   │   │   │   ├── file_backed_index/
    │   │   │   │   │   ├── mod.rs
    │   │   │   │   │   ├── serialize.rs
    │   │   │   │   │   └── shards.rs
    │   │   │   │   ├── file_backed_metastore_factory.rs
    │   │   │   │   ├── index_id_matcher.rs
    │   │   │   │   ├── index_template_matcher.rs
    │   │   │   │   ├── lazy_file_backed_index.rs
    │   │   │   │   ├── manifest.rs
    │   │   │   │   ├── mod.rs
    │   │   │   │   ├── state.rs
    │   │   │   │   └── store_operations.rs
    │   │   │   ├── index_metadata/
    │   │   │   │   ├── mod.rs
    │   │   │   │   └── serialize.rs
    │   │   │   ├── mod.rs
    │   │   │   └── postgres/
    │   │   │       ├── error.rs
    │   │   │       ├── factory.rs
    │   │   │       ├── metastore.rs
    │   │   │       ├── metrics.rs
    │   │   │       ├── migrator.rs
    │   │   │       ├── mod.rs
    │   │   │       ├── model.rs
    │   │   │       ├── pool.rs
    │   │   │       ├── queries/
    │   │   │       │   ├── index_templates/
    │   │   │       │   │   ├── find.sql
    │   │   │       │   │   ├── insert.sql
    │   │   │       │   │   └── upsert.sql
    │   │   │       │   ├── indexes_metadata.sql
    │   │   │       │   └── shards/
    │   │   │       │       ├── acquire.sql
    │   │   │       │       ├── delete.sql
    │   │   │       │       ├── fetch.sql
    │   │   │       │       ├── find_not_deletable.sql
    │   │   │       │       ├── insert.sql
    │   │   │       │       ├── open.sql
    │   │   │       │       ├── prune_age.sql
    │   │   │       │       └── prune_count.sql
    │   │   │       ├── split_stream.rs
    │   │   │       ├── tags.rs
    │   │   │       └── utils.rs
    │   │   ├── metastore_factory.rs
    │   │   ├── metastore_resolver.rs
    │   │   ├── split_metadata.rs
    │   │   ├── split_metadata_version.rs
    │   │   └── tests/
    │   │       ├── delete_task.rs
    │   │       ├── get_identity.rs
    │   │       ├── index.rs
    │   │       ├── list_splits.rs
    │   │       ├── mod.rs
    │   │       ├── shard.rs
    │   │       ├── source.rs
    │   │       ├── split.rs
    │   │       └── template.rs
    │   └── test-data/
    │       ├── .gitignore
    │       ├── file-backed-index/
    │       │   ├── v0.7.expected.json
    │       │   ├── v0.7.json
    │       │   ├── v0.8.expected.json
    │       │   ├── v0.8.json
    │       │   ├── v0.9.expected.json
    │       │   └── v0.9.json
    │       ├── index-metadata/
    │       │   ├── v0.7.expected.json
    │       │   ├── v0.7.json
    │       │   ├── v0.8.expected.json
    │       │   ├── v0.8.json
    │       │   ├── v0.9.expected.json
    │       │   └── v0.9.json
    │       ├── manifest/
    │       │   ├── v0.7.expected.json
    │       │   ├── v0.7.json
    │       │   ├── v0.8.expected.json
    │       │   ├── v0.8.json
    │       │   ├── v0.9.expected.json
    │       │   └── v0.9.json
    │       └── split-metadata/
    │           ├── v0.7.expected.json
    │           ├── v0.7.json
    │           ├── v0.8.expected.json
    │           ├── v0.8.json
    │           ├── v0.9.expected.json
    │           └── v0.9.json
    ├── quickwit-metastore-utils/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── bin/
    │       │   ├── README.md
    │       │   ├── proxy.rs
    │       │   └── replay.rs
    │       ├── grpc_request.rs
    │       └── lib.rs
    ├── quickwit-opentelemetry/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── lib.rs
    │       └── otlp/
    │           ├── logs.rs
    │           ├── metrics.rs
    │           ├── mod.rs
    │           ├── test_utils.rs
    │           └── traces.rs
    ├── quickwit-proto/
    │   ├── .gitignore
    │   ├── Cargo.toml
    │   ├── build.rs
    │   ├── protos/
    │   │   ├── quickwit/
    │   │   │   ├── cluster.proto
    │   │   │   ├── common.proto
    │   │   │   ├── control_plane.proto
    │   │   │   ├── developer.proto
    │   │   │   ├── indexing.proto
    │   │   │   ├── ingest.proto
    │   │   │   ├── ingester.proto
    │   │   │   ├── metastore.proto
    │   │   │   ├── router.proto
    │   │   │   └── search.proto
    │   │   └── third-party/
    │   │       ├── gogoproto/
    │   │       │   └── gogo.proto
    │   │       ├── google/
    │   │       │   └── protobuf/
    │   │       │       ├── any.proto
    │   │       │       ├── api.proto
    │   │       │       ├── descriptor.proto
    │   │       │       ├── duration.proto
    │   │       │       ├── empty.proto
    │   │       │       ├── field_mask.proto
    │   │       │       ├── source_context.proto
    │   │       │       ├── struct.proto
    │   │       │       ├── timestamp.proto
    │   │       │       ├── type.proto
    │   │       │       └── wrappers.proto
    │   │       ├── jaeger/
    │   │       │   ├── model.proto
    │   │       │   ├── storage/
    │   │       │   │   └── v2/
    │   │       │   │       └── trace_storage.proto
    │   │       │   └── storage.proto
    │   │       └── opentelemetry/
    │   │           └── proto/
    │   │               ├── collector/
    │   │               │   ├── README.md
    │   │               │   ├── logs/
    │   │               │   │   └── v1/
    │   │               │   │       ├── logs_service.proto
    │   │               │   │       └── logs_service_http.yaml
    │   │               │   ├── metrics/
    │   │               │   │   └── v1/
    │   │               │   │       ├── metrics_service.proto
    │   │               │   │       └── metrics_service_http.yaml
    │   │               │   └── trace/
    │   │               │       └── v1/
    │   │               │           ├── trace_service.proto
    │   │               │           └── trace_service_http.yaml
    │   │               ├── common/
    │   │               │   └── v1/
    │   │               │       └── common.proto
    │   │               ├── logs/
    │   │               │   └── v1/
    │   │               │       └── logs.proto
    │   │               ├── metrics/
    │   │               │   └── v1/
    │   │               │       └── metrics.proto
    │   │               ├── resource/
    │   │               │   └── v1/
    │   │               │       └── resource.proto
    │   │               └── trace/
    │   │                   └── v1/
    │   │                       └── trace.proto
    │   └── src/
    │       ├── cluster/
    │       │   └── mod.rs
    │       ├── codegen/
    │       │   ├── jaeger/
    │       │   │   ├── jaeger.api_v2.rs
    │       │   │   ├── jaeger.storage.v1.rs
    │       │   │   ├── jaeger.storage.v2.rs
    │       │   │   ├── opentelemetry.proto.common.v1.rs
    │       │   │   ├── opentelemetry.proto.resource.v1.rs
    │       │   │   └── opentelemetry.proto.trace.v1.rs
    │       │   ├── opentelemetry/
    │       │   │   ├── opentelemetry.proto.collector.logs.v1.rs
    │       │   │   ├── opentelemetry.proto.collector.metrics.v1.rs
    │       │   │   ├── opentelemetry.proto.collector.trace.v1.rs
    │       │   │   ├── opentelemetry.proto.common.v1.rs
    │       │   │   ├── opentelemetry.proto.logs.v1.rs
    │       │   │   ├── opentelemetry.proto.metrics.v1.rs
    │       │   │   ├── opentelemetry.proto.resource.v1.rs
    │       │   │   └── opentelemetry.proto.trace.v1.rs
    │       │   └── quickwit/
    │       │       ├── quickwit.cluster.rs
    │       │       ├── quickwit.common.rs
    │       │       ├── quickwit.control_plane.rs
    │       │       ├── quickwit.developer.rs
    │       │       ├── quickwit.indexing.rs
    │       │       ├── quickwit.ingest.ingester.rs
    │       │       ├── quickwit.ingest.router.rs
    │       │       ├── quickwit.ingest.rs
    │       │       ├── quickwit.metastore.rs
    │       │       └── quickwit.search.rs
    │       ├── control_plane/
    │       │   └── mod.rs
    │       ├── developer/
    │       │   └── mod.rs
    │       ├── error.rs
    │       ├── getters.rs
    │       ├── indexing/
    │       │   └── mod.rs
    │       ├── ingest/
    │       │   ├── ingester.rs
    │       │   ├── mod.rs
    │       │   └── router.rs
    │       ├── lib.rs
    │       ├── metastore/
    │       │   ├── events.rs
    │       │   └── mod.rs
    │       ├── search/
    │       │   ├── mod.rs
    │       │   ├── span_id.rs
    │       │   └── trace_id.rs
    │       └── types/
    │           ├── doc_mapping_uid.rs
    │           ├── doc_uid.rs
    │           ├── index_uid.rs
    │           ├── mod.rs
    │           ├── pipeline_uid.rs
    │           ├── position.rs
    │           └── shard_id.rs
    ├── quickwit-query/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── benches/
    │   │   └── tokenizers_bench.rs
    │   └── src/
    │       ├── aggregations.rs
    │       ├── elastic_query_dsl/
    │       │   ├── bool_query.rs
    │       │   ├── exists_query.rs
    │       │   ├── match_bool_prefix.rs
    │       │   ├── match_phrase_query.rs
    │       │   ├── match_query.rs
    │       │   ├── mod.rs
    │       │   ├── multi_match.rs
    │       │   ├── one_field_map.rs
    │       │   ├── phrase_prefix_query.rs
    │       │   ├── prefix_query.rs
    │       │   ├── query_string_query.rs
    │       │   ├── range_query.rs
    │       │   ├── regex_query.rs
    │       │   ├── string_or_struct.rs
    │       │   ├── term_query.rs
    │       │   ├── terms_query.rs
    │       │   ├── visitor.rs
    │       │   └── wildcard_query.rs
    │       ├── error.rs
    │       ├── json_literal.rs
    │       ├── lib.rs
    │       ├── not_nan_f32.rs
    │       ├── query_ast/
    │       │   ├── bool_query.rs
    │       │   ├── cache_node.rs
    │       │   ├── field_presence.rs
    │       │   ├── full_text_query.rs
    │       │   ├── mod.rs
    │       │   ├── phrase_prefix_query.rs
    │       │   ├── range_query.rs
    │       │   ├── regex_query.rs
    │       │   ├── tantivy_query_ast.rs
    │       │   ├── term_query.rs
    │       │   ├── term_set_query.rs
    │       │   ├── user_input_query.rs
    │       │   ├── utils.rs
    │       │   ├── visitor.rs
    │       │   └── wildcard_query.rs
    │       └── tokenizers/
    │           ├── chinese_compatible.rs
    │           ├── code_tokenizer.rs
    │           ├── mod.rs
    │           └── tokenizer_manager.rs
    ├── quickwit-rest-client/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── resources/
    │   │   └── tests/
    │   │       └── documents_to_ingest.json
    │   └── src/
    │       ├── error.rs
    │       ├── lib.rs
    │       ├── models.rs
    │       └── rest_client.rs
    ├── quickwit-search/
    │   ├── Cargo.toml
    │   ├── README.md
    │   └── src/
    │       ├── client.rs
    │       ├── cluster_client.rs
    │       ├── collector.rs
    │       ├── error.rs
    │       ├── fetch_docs.rs
    │       ├── find_trace_ids_collector.rs
    │       ├── invoker.rs
    │       ├── leaf.rs
    │       ├── leaf_cache.rs
    │       ├── lib.rs
    │       ├── list_fields.rs
    │       ├── list_fields_cache.rs
    │       ├── list_terms.rs
    │       ├── metrics.rs
    │       ├── metrics_trackers.rs
    │       ├── retry/
    │       │   ├── mod.rs
    │       │   └── search.rs
    │       ├── root.rs
    │       ├── scroll_context.rs
    │       ├── search_job_placer.rs
    │       ├── search_permit_provider.rs
    │       ├── search_response_rest.rs
    │       ├── service.rs
    │       ├── tests.rs
    │       └── top_k_collector.rs
    ├── quickwit-serve/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── build.rs
    │   ├── resources/
    │   │   └── tests/
    │   │       └── jaeger_ui_trace.json
    │   └── src/
    │       ├── build_info.rs
    │       ├── cluster_api/
    │       │   ├── mod.rs
    │       │   └── rest_handler.rs
    │       ├── decompression.rs
    │       ├── delete_task_api/
    │       │   ├── handler.rs
    │       │   └── mod.rs
    │       ├── developer_api/
    │       │   ├── debug.rs
    │       │   ├── heap_prof.rs
    │       │   ├── heap_prof_disabled.rs
    │       │   ├── log_level.rs
    │       │   ├── mod.rs
    │       │   ├── pprof.rs
    │       │   ├── pprof_disabled.rs
    │       │   └── server.rs
    │       ├── elasticsearch_api/
    │       │   ├── bulk.rs
    │       │   ├── bulk_v2.rs
    │       │   ├── filter.rs
    │       │   ├── mod.rs
    │       │   ├── model/
    │       │   │   ├── bulk_body.rs
    │       │   │   ├── bulk_query_params.rs
    │       │   │   ├── cat_indices.rs
    │       │   │   ├── error.rs
    │       │   │   ├── field_capability.rs
    │       │   │   ├── mappings.rs
    │       │   │   ├── mod.rs
    │       │   │   ├── multi_search.rs
    │       │   │   ├── scroll.rs
    │       │   │   ├── search_body.rs
    │       │   │   ├── search_query_params.rs
    │       │   │   ├── search_response.rs
    │       │   │   └── stats.rs
    │       │   └── rest_handler.rs
    │       ├── format.rs
    │       ├── grpc.rs
    │       ├── health_check_api/
    │       │   ├── handler.rs
    │       │   └── mod.rs
    │       ├── index_api/
    │       │   ├── index_resource.rs
    │       │   ├── mod.rs
    │       │   ├── rest_handler.rs
    │       │   ├── source_resource.rs
    │       │   └── split_resource.rs
    │       ├── indexing_api/
    │       │   ├── mod.rs
    │       │   └── rest_handler.rs
    │       ├── ingest_api/
    │       │   ├── mod.rs
    │       │   ├── response.rs
    │       │   └── rest_handler.rs
    │       ├── jaeger_api/
    │       │   ├── mod.rs
    │       │   ├── model.rs
    │       │   ├── parse_duration.rs
    │       │   └── rest_handler.rs
    │       ├── lib.rs
    │       ├── load_shield.rs
    │       ├── metrics.rs
    │       ├── metrics_api.rs
    │       ├── node_info_handler.rs
    │       ├── openapi.rs
    │       ├── otlp_api/
    │       │   ├── mod.rs
    │       │   └── rest_handler.rs
    │       ├── rate_modulator.rs
    │       ├── rest.rs
    │       ├── rest_api_response.rs
    │       ├── search_api/
    │       │   ├── grpc_adapter.rs
    │       │   ├── mod.rs
    │       │   └── rest_handler.rs
    │       ├── simple_list.rs
    │       ├── tcp_listener.rs
    │       ├── template_api/
    │       │   ├── mod.rs
    │       │   └── rest_handler.rs
    │       └── ui_handler.rs
    ├── quickwit-storage/
    │   ├── Cargo.toml
    │   ├── src/
    │   │   ├── bundle_storage.rs
    │   │   ├── cache/
    │   │   │   ├── base_cache.rs
    │   │   │   ├── byte_range_cache.rs
    │   │   │   ├── memory_sized_cache.rs
    │   │   │   ├── mod.rs
    │   │   │   ├── quickwit_cache.rs
    │   │   │   ├── slice_address.rs
    │   │   │   ├── storage_with_cache.rs
    │   │   │   └── stored_item.rs
    │   │   ├── debouncer.rs
    │   │   ├── error.rs
    │   │   ├── file_descriptor_cache.rs
    │   │   ├── lib.rs
    │   │   ├── local_file_storage.rs
    │   │   ├── metrics.rs
    │   │   ├── object_storage/
    │   │   │   ├── azure_blob_storage.rs
    │   │   │   ├── error.rs
    │   │   │   ├── mod.rs
    │   │   │   ├── policy.rs
    │   │   │   ├── s3_compatible_storage.rs
    │   │   │   └── s3_compatible_storage_resolver.rs
    │   │   ├── opendal_storage/
    │   │   │   ├── base.rs
    │   │   │   ├── google_cloud_storage.rs
    │   │   │   └── mod.rs
    │   │   ├── payload.rs
    │   │   ├── prefix_storage.rs
    │   │   ├── ram_storage.rs
    │   │   ├── split.rs
    │   │   ├── split_cache/
    │   │   │   ├── download_task.rs
    │   │   │   ├── mod.rs
    │   │   │   ├── split_table.rs
    │   │   │   └── tests.rs
    │   │   ├── storage.rs
    │   │   ├── storage_factory.rs
    │   │   ├── storage_resolver.rs
    │   │   ├── timeout_and_retry_storage.rs
    │   │   └── versioned_component.rs
    │   └── tests/
    │       ├── azure_storage.rs
    │       ├── google_cloud_storage.rs
    │       └── s3_storage.rs
    ├── quickwit-telemetry/
    │   ├── Cargo.toml
    │   └── src/
    │       ├── lib.rs
    │       ├── payload.rs
    │       ├── sender.rs
    │       └── sink.rs
    ├── quickwit-ui/
    │   ├── .gitignore
    │   ├── .gitignore_for_build_directory
    │   ├── Makefile
    │   ├── README.md
    │   ├── biome.json
    │   ├── build/
    │   │   └── .gitignore
    │   ├── e2e/
    │   │   └── homepage.spec.ts
    │   ├── index.html
    │   ├── jest/
    │   │   └── setup.js
    │   ├── jest.config.js
    │   ├── mocks/
    │   │   ├── monacoMock.js
    │   │   ├── swaggerUIMock.js
    │   │   └── x-charts.js
    │   ├── package.json
    │   ├── playwright.config.ts
    │   ├── public/
    │   │   ├── manifest.json
    │   │   └── robots.txt
    │   ├── src/
    │   │   ├── components/
    │   │   │   ├── ApiUrlFooter.tsx
    │   │   │   ├── IndexSideBar.tsx
    │   │   │   ├── IndexSummary.tsx
    │   │   │   ├── IndexesTable.tsx
    │   │   │   ├── JsonEditor.tsx
    │   │   │   ├── LayoutUtils.tsx
    │   │   │   ├── Loader.tsx
    │   │   │   ├── QueryActionBar.tsx
    │   │   │   ├── QueryEditor/
    │   │   │   │   ├── AggregationEditor.tsx
    │   │   │   │   ├── QueryEditor.tsx
    │   │   │   │   └── config.ts
    │   │   │   ├── ResponseErrorDisplay.tsx
    │   │   │   ├── SearchResult/
    │   │   │   │   ├── AggregationResult.tsx
    │   │   │   │   ├── ResultTable.tsx
    │   │   │   │   ├── Row.tsx
    │   │   │   │   └── SearchResult.tsx
    │   │   │   ├── SideBar.tsx
    │   │   │   ├── TimeRangeSelect.tsx
    │   │   │   └── TopBar.tsx
    │   │   ├── index.css
    │   │   ├── index.test.js
    │   │   ├── index.tsx
    │   │   ├── providers/
    │   │   │   ├── EditorProvider.tsx
    │   │   │   └── LocalStorageProvider.tsx
    │   │   ├── services/
    │   │   │   ├── client.test.ts
    │   │   │   └── client.ts
    │   │   ├── utils/
    │   │   │   ├── SearchComponentProps.ts
    │   │   │   ├── models.ts
    │   │   │   ├── theme.ts
    │   │   │   └── urls.ts
    │   │   └── views/
    │   │       ├── ApiView.tsx
    │   │       ├── App.tsx
    │   │       ├── ClusterView.test.jsx
    │   │       ├── ClusterView.tsx
    │   │       ├── IndexView.test.jsx
    │   │       ├── IndexView.tsx
    │   │       ├── IndexesView.test.jsx
    │   │       ├── IndexesView.tsx
    │   │       ├── NodeInfoView.test.jsx
    │   │       ├── NodeInfoView.tsx
    │   │       ├── SearchView.test.jsx
    │   │       └── SearchView.tsx
    │   ├── tsconfig.json
    │   └── vite.config.ts
    ├── rest-api-tests/
    │   ├── Pipfile
    │   ├── README.md
    │   ├── docker-compose.yaml
    │   ├── run_tests.py
    │   └── scenarii/
    │       ├── aggregations/
    │       │   ├── 0001-aggregations.yaml
    │       │   ├── 0002-doc-len.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   └── _teardown.quickwit.yaml
    │       ├── concat_fields/
    │       │   ├── 0001_concat_field.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   └── _teardown.quickwit.yaml
    │       ├── default_search_fields/
    │       │   ├── 0001_default_fields.yaml
    │       │   ├── 0002_invalid_default_fields.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   └── _teardown.quickwit.yaml
    │       ├── es_compatibility/
    │       │   ├── 0001-noquery.yaml
    │       │   ├── 0002-query_string.yaml
    │       │   ├── 0003-match.yaml
    │       │   ├── 0004-term_aggregations.yaml
    │       │   ├── 0005-query_string_query.yaml
    │       │   ├── 0006-term_query.yaml
    │       │   ├── 0007-range_queries.yaml
    │       │   ├── 0008-sort_by.yaml
    │       │   ├── 0009-bool_query.yaml
    │       │   ├── 0010-match_phrase_prefix_query.yaml
    │       │   ├── 0011-exists-query.yaml
    │       │   ├── 0012-scroll-api.yaml
    │       │   ├── 0013-phrase-query.yaml
    │       │   ├── 0014-multi-match-query.yaml
    │       │   ├── 0015-terms-query.yaml
    │       │   ├── 0016-misc-query.yaml
    │       │   ├── 0017-match-bool-prefix-query.yaml
    │       │   ├── 0018-search_after.yaml
    │       │   ├── 0019-count.yaml
    │       │   ├── 0020-stats.yaml
    │       │   ├── 0021-cat-indices.yaml
    │       │   ├── 0022-source.yaml
    │       │   ├── 0023-extra_filters.yaml
    │       │   ├── 0024-delete_indices.yaml
    │       │   ├── 0025-msearch.yaml
    │       │   ├── 0026-resolve.yaml
    │       │   ├── 0027-cluster-health.yaml
    │       │   ├── 0028-fast_only_field_query.yaml
    │       │   ├── 0029-wildcard.yaml
    │       │   ├── 0030-prefix.yaml
    │       │   ├── 0031-regex.yaml
    │       │   ├── 0032-mappings.yaml
    │       │   ├── _ctx.elasticsearch.yaml
    │       │   ├── _ctx.quickwit.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.elasticsearch.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   ├── _teardown.elasticsearch.yaml
    │       │   ├── _teardown.quickwit.yaml
    │       │   ├── bulk/
    │       │   │   ├── 0001-happy-path.yaml
    │       │   │   ├── 0002-malformed-action.yaml
    │       │   │   ├── 0003-validation-failed-index-missing.yaml
    │       │   │   ├── 0004-put-request.yaml
    │       │   │   ├── 0005-document-parsing-exception.yaml
    │       │   │   ├── 0006-partial-index-not-found.yaml
    │       │   │   ├── 0007-illegal-index-name.yaml
    │       │   │   ├── _ctx.elasticsearch.yaml
    │       │   │   ├── _ctx.quickwit.yaml
    │       │   │   ├── _ctx.yaml
    │       │   │   ├── _setup.elasticsearch.yaml
    │       │   │   ├── _setup.quickwit.yaml
    │       │   │   ├── _teardown.elasticsearch.yaml
    │       │   │   └── _teardown.quickwit.yaml
    │       │   └── multi-indices/
    │       │       ├── 0001-muti_indices_query.yaml
    │       │       ├── 0002-muti_indices_scroll.yaml
    │       │       ├── 0003-multi_indices_aggs.yaml
    │       │       ├── 0004-missing_index_query.yaml
    │       │       ├── _ctx.yaml
    │       │       ├── _setup.elasticsearch.yaml
    │       │       ├── _setup.quickwit.yaml
    │       │       ├── _teardown.elasticsearch.yaml
    │       │       └── _teardown.quickwit.yaml
    │       ├── es_compatibility_info/
    │       │   ├── 0001-info.yaml
    │       │   ├── _ctx.elasticsearch.yaml
    │       │   ├── _ctx.quickwit.yaml
    │       │   └── _ctx.yaml
    │       ├── es_field_capabilities/
    │       │   ├── 0001-field-capabilities.yaml
    │       │   ├── _ctx.elasticsearch.yaml
    │       │   ├── _ctx.quickwit.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.elasticsearch.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   ├── _teardown.elasticsearch.yaml
    │       │   └── _teardown.quickwit.yaml
    │       ├── multi_splits/
    │       │   ├── 0001-request-optimizations.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   └── _teardown.quickwit.yaml
    │       ├── qw_search_api/
    │       │   ├── 0001_ts_range.yaml
    │       │   ├── 0002_negative_search.yaml
    │       │   ├── 0003_exists_search.yaml
    │       │   ├── 0004_exact_string.yaml
    │       │   ├── 0005_fast_field_search.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   └── _teardown.quickwit.yaml
    │       ├── search_after/
    │       │   ├── 0001-search_after_edge_case.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   └── _teardown.quickwit.yaml
    │       ├── sort_orders/
    │       │   ├── 0001-sort-elasticapi.yaml
    │       │   ├── _ctx.yaml
    │       │   ├── _setup.quickwit.yaml
    │       │   └── _teardown.quickwit.yaml
    │       └── tag_fields/
    │           ├── 0001_allowed_types.yaml
    │           ├── 0002_negative_tags.yaml
    │           ├── _ctx.yaml
    │           ├── _setup.quickwit.yaml
    │           └── _teardown.quickwit.yaml
    ├── rust-toolchain.toml
    ├── rustfmt.toml
    └── scripts/
        ├── about.hbs
        ├── about.toml
        ├── check_license_headers.sh
        ├── check_log_format.sh
        └── dep-tree.py

SYMBOL INDEX (12934 symbols across 627 files)

FILE: quickwit/quickwit-actors/benches/bench.rs
  type DoNothingActor (line 20) | struct DoNothingActor<const YIELD_AFTER_EACH_MESSAGE: bool>(u64);
  type ObservableState (line 24) | type ObservableState = u64;
  method observable_state (line 26) | fn observable_state(&self) -> u64 {
  method yield_after_each_message (line 30) | fn yield_after_each_message(&self) -> bool {
  type AddMessage (line 36) | struct AddMessage(u64);
  type Reply (line 42) | type Reply = ();
  function handle (line 44) | async fn handle(
  function actor_bench_code (line 54) | async fn actor_bench_code<const YIELD_AFTER_EACH_MESSAGE: bool>(num_mess...
  function flume_bench_code (line 66) | async fn flume_bench_code(num_messages: usize) {
  function chan_with_priority_bench_code (line 83) | async fn chan_with_priority_bench_code(num_messages: usize) {
  function message_throughput (line 101) | fn message_throughput(c: &mut Criterion) {

FILE: quickwit/quickwit-actors/examples/ping_actor.rs
  type PingReceiver (line 21) | struct PingReceiver {
    method with_name (line 27) | pub fn with_name(name: &'static str) -> Self {
    type Reply (line 45) | type Reply = String;
    method handle (line 46) | async fn handle(
  type ObservableState (line 36) | type ObservableState = usize;
  method observable_state (line 38) | fn observable_state(&self) -> Self::ObservableState {
  type PingSender (line 62) | struct PingSender {
    type Reply (line 89) | type Reply = ();
    method handle (line 91) | async fn handle(&mut self, _: Loop, ctx: &ActorContext<Self>) -> Resul...
    type Reply (line 114) | type Reply = ();
    method handle (line 116) | async fn handle(
  type Loop (line 68) | struct Loop;
  type Ping (line 71) | struct Ping;
  type AddPeer (line 74) | pub struct AddPeer(Mailbox<PingReceiver>);
  type ObservableState (line 78) | type ObservableState = ();
  method observable_state (line 79) | fn observable_state(&self) -> Self::ObservableState {}
  method initialize (line 81) | async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(), A...
  function main (line 128) | async fn main() {

FILE: quickwit/quickwit-actors/src/actor.rs
  type ActorExitStatus (line 29) | pub enum ActorExitStatus {
    method from (line 77) | fn from(err: anyhow::Error) -> Self {
    method is_success (line 83) | pub fn is_success(&self) -> bool {
    method from (line 89) | fn from(_: SendError) -> Self {
  type Actor (line 101) | pub trait Actor: Send + Sized + 'static {
    method name (line 110) | fn name(&self) -> String {
    method runtime_handle (line 119) | fn runtime_handle(&self) -> tokio::runtime::Handle {
    method yield_after_each_message (line 128) | fn yield_after_each_message(&self) -> bool {
    method queue_capacity (line 133) | fn queue_capacity(&self) -> QueueCapacity {
    method observable_state (line 140) | fn observable_state(&self) -> Self::ObservableState;
    method initialize (line 152) | async fn initialize(&mut self, _ctx: &ActorContext<Self>) -> Result<()...
    method on_drained_messages (line 164) | async fn on_drained_messages(
    method finalize (line 180) | async fn finalize(
  type DeferableReplyHandler (line 191) | pub trait DeferableReplyHandler<M>: Actor {
    method handle_message (line 194) | async fn handle_message(
  type Handler (line 206) | pub trait Handler<M>: Actor {
    method handle (line 214) | async fn handle(
  type Reply (line 225) | type Reply = H::Reply;
  method handle_message (line 227) | async fn handle_message(

FILE: quickwit/quickwit-actors/src/actor_context.rs
  type ActorContext (line 39) | pub struct ActorContext<A: Actor> {
  method clone (line 44) | fn clone(&self) -> Self {
  type Target (line 52) | type Target = ActorContextInner<A>;
  method deref (line 54) | fn deref(&self) -> &Self::Target {
  type ActorContextInner (line 59) | pub struct ActorContextInner<A: Actor> {
  function new (line 71) | pub(crate) fn new(
  function spawn_ctx (line 91) | pub fn spawn_ctx(&self) -> &SpawnContext {
  function sleep (line 102) | pub async fn sleep(&self, duration: Duration) {
  function for_test (line 110) | pub fn for_test(
  function mailbox (line 123) | pub fn mailbox(&self) -> &Mailbox<A> {
  function registry (line 127) | pub(crate) fn registry(&self) -> &ActorRegistry {
  function actor_instance_id (line 131) | pub fn actor_instance_id(&self) -> &str {
  function protect_zone (line 142) | pub fn protect_zone(&self) -> ProtectedZoneGuard {
  function protect_future (line 147) | pub async fn protect_future<Fut, T>(&self, future: Fut) -> T
  function yield_now (line 154) | pub async fn yield_now(&self) {
  function kill_switch (line 163) | pub fn kill_switch(&self) -> &KillSwitch {
  function progress (line 168) | pub fn progress(&self) -> &Progress {
  function spawn_actor (line 172) | pub fn spawn_actor<SpawnedActor: Actor>(&self) -> SpawnBuilder<SpawnedAc...
  function record_progress (line 181) | pub fn record_progress(&self) {
  function state (line 185) | pub(crate) fn state(&self) -> ActorState {
  function pause (line 189) | pub fn pause(&self) {
  function resume (line 193) | pub(crate) fn resume(&self) {
  function set_observe_enqueued_and_return_previous (line 200) | pub(crate) fn set_observe_enqueued_and_return_previous(&self) -> bool {
  function observe (line 205) | pub fn observe(&self, actor: &mut A) -> A::ObservableState {
  function exit (line 212) | pub(crate) fn exit(&self, exit_status: &ActorExitStatus) {
  function send_message (line 239) | pub async fn send_message<DestActor, M>(
  function ask (line 258) | pub async fn ask<DestActor, M, T>(
  function ask_for_res (line 276) | pub async fn ask_for_res<DestActor, M, T, E>(
  function send_exit_with_success (line 295) | pub async fn send_exit_with_success<Dest: Actor>(
  function send_self_message (line 309) | pub async fn send_self_message<M>(
  function try_send_self_message (line 326) | pub fn try_send_self_message<M>(
  function schedule_self_msg (line 342) | pub fn schedule_self_msg<M>(&self, after_duration: Duration, message: M)
  function should_activate_kill_switch (line 358) | fn should_activate_kill_switch(exit_status: &ActorExitStatus) -> bool {

FILE: quickwit/quickwit-actors/src/actor_handle.rs
  type ActorHandle (line 30) | pub struct ActorHandle<A: Actor> {
  type Health (line 38) | pub enum Health {
  type Healthz (line 49) | pub struct Healthz;
  function fmt (line 52) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type Supervisable (line 60) | pub trait Supervisable {
    method name (line 61) | fn name(&self) -> &str;
    method check_health (line 65) | fn check_health(&self, check_for_progress: bool) -> Health;
    method state (line 67) | fn state(&self) -> ActorState;
    method name (line 71) | fn name(&self) -> &str {
    method state (line 75) | fn state(&self) -> ActorState {
    method check_health (line 86) | fn check_health(&self, check_for_progress: bool) -> Health {
  function new (line 110) | pub(crate) fn new(
  function state (line 122) | pub fn state(&self) -> ActorState {
  function process_pending_and_observe (line 135) | pub async fn process_pending_and_observe(&self) -> Observation<A::Observ...
  function observe (line 146) | pub async fn observe(&self) -> Observation<A::ObservableState> {
  function refresh_observe (line 161) | pub fn refresh_observe(&self) {
  function observe_with_priority (line 173) | async fn observe_with_priority(&self, priority: Priority) -> Observation...
  function pause (line 201) | pub fn pause(&self) {
  function resume (line 209) | pub fn resume(&self) {
  function kill (line 222) | pub async fn kill(self) -> (ActorExitStatus, A::ObservableState) {
  function quit (line 238) | pub async fn quit(self) -> (ActorExitStatus, A::ObservableState) {
  function join (line 247) | pub async fn join(self) -> (ActorExitStatus, A::ObservableState) {
  function last_observation (line 253) | pub fn last_observation(&self) -> impl Deref<Target = A::ObservableState...
  function wait_for_observable_state_callback (line 257) | async fn wait_for_observable_state_callback(
  function mailbox (line 286) | pub fn mailbox(&self) -> &Mailbox<A> {
  type PanickingActor (line 302) | struct PanickingActor {
    type Reply (line 318) | type Reply = ();
    method handle (line 319) | async fn handle(
  type ObservableState (line 307) | type ObservableState = usize;
  method observable_state (line 308) | fn observable_state(&self) -> usize {
  type Panic (line 314) | struct Panic;
  type ExitActor (line 330) | struct ExitActor {
    type Reply (line 346) | type Reply = ();
    method handle (line 348) | async fn handle(
  type ObservableState (line 335) | type ObservableState = usize;
  method observable_state (line 336) | fn observable_state(&self) -> usize {
  type Exit (line 342) | struct Exit;
  function test_panic_in_actor (line 359) | async fn test_panic_in_actor() -> anyhow::Result<()> {
  function test_exit (line 370) | async fn test_exit() -> anyhow::Result<()> {
  type ObserveActor (line 381) | struct ObserveActor {
    type Reply (line 404) | type Reply = ();
    method handle (line 405) | async fn handle(
  type ObservableState (line 387) | type ObservableState = u32;
  method observable_state (line 389) | fn observable_state(&self) -> u32 {
  method initialize (line 393) | async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(), A...
  type YieldLoop (line 400) | struct YieldLoop;
  function test_observation_debounce (line 417) | async fn test_observation_debounce() {

FILE: quickwit/quickwit-actors/src/actor_state.rs
  type ActorState (line 19) | pub enum ActorState {
    method from (line 33) | fn from(actor_state_u32: u32) -> Self {
    method is_running (line 56) | pub fn is_running(&self) -> bool {
    method is_exit (line 60) | pub fn is_exit(&self) -> bool {
  type AtomicState (line 68) | pub(crate) struct AtomicState(AtomicU32);
    method from (line 50) | fn from(state: ActorState) -> Self {
    method pause (line 77) | pub(crate) fn pause(&self) {
    method resume (line 88) | pub(crate) fn resume(&self) {
    method exit (line 97) | pub(crate) fn exit(&self, success: bool) {
    method get_state (line 106) | pub fn get_state(&self) -> ActorState {
  method default (line 71) | fn default() -> Self {
  type Operation (line 115) | enum Operation {
    method apply (line 123) | fn apply(&self, state: &AtomicState) {
  function test_transition (line 136) | fn test_transition(from_state: ActorState, op: Operation, expected_state...
  function test_atomic_state_from_running (line 143) | fn test_atomic_state_from_running() {

FILE: quickwit/quickwit-actors/src/channel_with_priority.rs
  type LockedOption (line 22) | struct LockedOption<T> {
  function none (line 28) | pub fn none() -> Self {
  function is_some (line 35) | pub fn is_some(&self) -> bool {
  function is_none (line 39) | pub fn is_none(&self) -> bool {
  function take (line 43) | pub fn take(&self) -> Option<T> {
  function place (line 53) | pub fn place(&self, val: T) {
  type SendError (line 61) | pub enum SendError {
    method from (line 103) | fn from(_send_error: flume::SendError<T>) -> Self {
    method from (line 109) | fn from(try_send_error: flume::TrySendError<T>) -> Self {
  type TrySendError (line 69) | pub enum TrySendError<M> {
  function from (line 77) | fn from(err: flume::TrySendError<M>) -> Self {
  type RecvError (line 86) | pub enum RecvError {
    method from (line 94) | fn from(flume_err: flume::RecvTimeoutError) -> Self {
  type QueueCapacity (line 118) | pub enum QueueCapacity {
  function channel (line 127) | pub fn channel<T>(queue_capacity: QueueCapacity) -> (Sender<T>, Receiver...
  type Sender (line 147) | pub struct Sender<T> {
  function is_disconnected (line 153) | pub fn is_disconnected(&self) -> bool {
  function try_send_low_priority (line 157) | pub fn try_send_low_priority(&self, msg: T) -> Result<(), TrySendError<T...
  function send_low_priority (line 162) | pub async fn send_low_priority(&self, msg: T) -> Result<(), SendError> {
  function send_high_priority (line 167) | pub fn send_high_priority(&self, msg: T) -> Result<(), SendError> {
  type CloneIsForbidden (line 176) | struct CloneIsForbidden;
  type Receiver (line 178) | pub struct Receiver<T> {
  method drop (line 187) | fn drop(&mut self) {
  function is_empty (line 199) | pub fn is_empty(&self) -> bool {
  function try_recv_high_priority_message (line 205) | pub fn try_recv_high_priority_message(&self) -> Result<T, RecvError> {
  function try_recv (line 229) | pub fn try_recv(&self) -> Result<T, RecvError> {
  function recv_high_priority (line 256) | pub async fn recv_high_priority(&self) -> T {
  function recv (line 263) | pub async fn recv(&self) -> Result<T, RecvError> {
  function drain_low_priority (line 307) | pub fn drain_low_priority(&self) -> Vec<T> {
  function test_channel_with_priority_drop_receiver_drop_messages (line 324) | async fn test_channel_with_priority_drop_receiver_drop_messages() {
  function test_locked_option_new_empty (line 338) | fn test_locked_option_new_empty() {
  function test_locked_option_place (line 344) | fn test_locked_option_place() {
  function test_locked_option_place_twice_keep_last (line 351) | fn test_locked_option_place_twice_keep_last() {
  function test_locked_option_place_take_twice (line 359) | fn test_locked_option_place_take_twice() {
  function test_recv_priority (line 367) | async fn test_recv_priority() -> anyhow::Result<()> {
  function test_try_recv (line 382) | async fn test_try_recv() -> anyhow::Result<()> {
  function test_try_recv_high_priority (line 391) | async fn test_try_recv_high_priority() -> anyhow::Result<()> {
  function test_recv_high_priority_ignore_disconnection (line 402) | async fn test_recv_high_priority_ignore_disconnection() -> anyhow::Resul...
  function test_recv_disconnect (line 414) | async fn test_recv_disconnect() -> anyhow::Result<()> {
  function test_recv_timeout_simple (line 422) | async fn test_recv_timeout_simple() -> anyhow::Result<()> {
  function test_try_recv_priority_corner_case (line 432) | async fn test_try_recv_priority_corner_case() -> anyhow::Result<()> {
  function test_try_recv_high_low (line 447) | async fn test_try_recv_high_low() {
  function test_try_recv_high (line 457) | async fn test_try_recv_high() {

FILE: quickwit/quickwit-actors/src/command.rs
  type Command (line 25) | pub enum Command {
  type Reply (line 85) | type Reply = ();
  method handle (line 88) | async fn handle(
  type Observe (line 114) | pub struct Observe;
  type Reply (line 118) | type Reply = A::ObservableState;
  method handle (line 120) | async fn handle(

FILE: quickwit/quickwit-actors/src/envelope.rs
  type Envelope (line 32) | pub struct Envelope<A> {
  function message (line 41) | pub fn message(&mut self) -> Box<dyn Any> {
  function message_typed (line 45) | pub fn message_typed<M: 'static>(&mut self) -> Option<M> {
  function handle_message (line 56) | pub async fn handle_message(
  function fmt (line 70) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type EnvelopeT (line 77) | trait EnvelopeT<A: Actor>: Send {
    method message_type_name (line 78) | fn message_type_name(&self) -> &'static str;
    method debug_msg (line 80) | fn debug_msg(&self) -> String;
    method message (line 85) | fn message(&mut self) -> Box<dyn Any>;
    method handle_message (line 88) | async fn handle_message(
  function message_type_name (line 101) | fn message_type_name(&self) -> &'static str {
  function debug_msg (line 105) | fn debug_msg(&self) -> String {
  function message (line 114) | fn message(&mut self) -> Box<dyn Any> {
  function handle_message (line 122) | async fn handle_message(
  function wrap_in_envelope (line 145) | pub(crate) fn wrap_in_envelope<A, M>(

FILE: quickwit/quickwit-actors/src/lib.rs
  function heartbeat_from_env_or_default (line 78) | fn heartbeat_from_env_or_default() -> Duration {
  constant OBSERVE_TIMEOUT (line 113) | const OBSERVE_TIMEOUT: Duration = Duration::from_secs(3);
  type AskError (line 117) | pub enum AskError<E: fmt::Debug> {

FILE: quickwit/quickwit-actors/src/mailbox.rs
  type Mailbox (line 46) | pub struct Mailbox<A: Actor> {
  function downgrade (line 55) | pub fn downgrade(&self) -> WeakMailbox<A> {
  method drop (line 64) | fn drop(&mut self) {
  type Priority (line 76) | pub(crate) enum Priority {
  method clone (line 82) | fn clone(&self) -> Self {
  function is_last_mailbox (line 92) | pub(crate) fn is_last_mailbox(&self) -> bool {
  function id (line 96) | pub fn id(&self) -> &str {
  function scheduler_client (line 100) | pub(crate) fn scheduler_client(&self) -> Option<&SchedulerClient> {
  type Inner (line 105) | struct Inner<A: Actor> {
  function fmt (line 112) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function actor_instance_id (line 120) | pub fn actor_instance_id(&self) -> &str {
  function is_disconnected (line 124) | pub fn is_disconnected(&self) -> bool {
  function send_message (line 133) | pub async fn send_message<M>(
  function try_send_message (line 148) | pub fn try_send_message<M>(
  function wrap_in_envelope (line 173) | fn wrap_in_envelope<M>(&self, message: M) -> (Envelope<A>, oneshot::Rece...
  function send_message_with_backpressure_counter (line 191) | pub async fn send_message_with_backpressure_counter<M>(
  function send_message_with_high_priority (line 218) | pub fn send_message_with_high_priority<M>(
  function send_message_with_priority (line 231) | pub(crate) async fn send_message_with_priority<M>(
  function ask (line 254) | pub async fn ask<M, T>(&self, message: M) -> Result<T, AskError<Infallib...
  function ask_with_backpressure_counter (line 273) | pub async fn ask_with_backpressure_counter<M, T>(
  function ask_for_res (line 294) | pub async fn ask_for_res<M, T, E>(&self, message: M) -> Result<T, AskErr...
  type InboxInner (line 309) | struct InboxInner<A: Actor> {
  type Inbox (line 314) | pub struct Inbox<A: Actor> {
  method clone (line 319) | fn clone(&self) -> Self {
  function is_empty (line 327) | pub(crate) fn is_empty(&self) -> bool {
  function recv (line 331) | pub(crate) async fn recv(&self) -> Result<Envelope<A>, RecvError> {
  function recv_cmd_and_scheduled_msg_only (line 335) | pub(crate) async fn recv_cmd_and_scheduled_msg_only(&self) -> Envelope<A> {
  function try_recv (line 339) | pub(crate) fn try_recv(&self) -> Result<Envelope<A>, RecvError> {
  function recv_typed_message (line 344) | pub async fn recv_typed_message<M: 'static>(&self) -> Result<M, RecvErro...
  function drain_for_test (line 364) | pub fn drain_for_test(&self) -> Vec<Box<dyn Any>> {
  function drain_for_test_typed (line 378) | pub fn drain_for_test_typed<M: 'static>(&self) -> Vec<M> {
  function get_actor_inboxes_count_gauge_guard (line 388) | fn get_actor_inboxes_count_gauge_guard() -> GaugeGuard<'static> {
  function create_mailbox (line 403) | pub(crate) fn create_mailbox<A: Actor>(
  type WeakMailbox (line 428) | pub struct WeakMailbox<A: Actor> {
  method clone (line 434) | fn clone(&self) -> Self {
  function upgrade (line 443) | pub fn upgrade(&self) -> Option<Mailbox<A>> {
  function test_weak_mailbox_downgrade_upgrade (line 461) | async fn test_weak_mailbox_downgrade_upgrade() {
  function test_weak_mailbox_failing_upgrade (line 469) | async fn test_weak_mailbox_failing_upgrade() {
  type BackPressureActor (line 477) | struct BackPressureActor;
    type Reply (line 497) | type Reply = ();
    method handle (line 499) | async fn handle(
  type ObservableState (line 480) | type ObservableState = ();
  method observable_state (line 482) | fn observable_state(&self) -> Self::ObservableState {}
  method queue_capacity (line 484) | fn queue_capacity(&self) -> QueueCapacity {
  method yield_after_each_message (line 488) | fn yield_after_each_message(&self) -> bool {
  function test_mailbox_send_with_backpressure_counter_low_backpressure (line 512) | async fn test_mailbox_send_with_backpressure_counter_low_backpressure() {
  function test_mailbox_send_with_backpressure_counter_backpressure (line 540) | async fn test_mailbox_send_with_backpressure_counter_backpressure() {
  function test_mailbox_waiting_for_processing_does_not_counter_as_backpressure (line 574) | async fn test_mailbox_waiting_for_processing_does_not_counter_as_backpre...
  function test_try_send (line 596) | async fn test_try_send() {
  function test_try_send_disconnect (line 608) | async fn test_try_send_disconnect() {
  function test_weak_mailbox_ref_count (line 621) | async fn test_weak_mailbox_ref_count() {

FILE: quickwit/quickwit-actors/src/observation.rs
  type Observation (line 19) | pub struct Observation<ObservableState> {
  type Target (line 25) | type Target = ObservableState;
  method deref (line 27) | fn deref(&self) -> &Self::Target {
  type ObservationType (line 34) | pub enum ObservationType {
  method eq (line 47) | fn eq(&self, other: &Self) -> bool {

FILE: quickwit/quickwit-actors/src/registry.rs
  type TypedJsonObservable (line 32) | struct TypedJsonObservable<A: Actor> {
  type JsonObservable (line 39) | trait JsonObservable: Sync + Send {
    method is_disconnected (line 40) | fn is_disconnected(&self) -> bool;
    method any (line 41) | fn any(&self) -> &dyn Any;
    method actor_instance_id (line 42) | fn actor_instance_id(&self) -> &str;
    method observe (line 43) | async fn observe(&self) -> Option<JsonValue>;
    method quit (line 44) | async fn quit(&self) -> ActorExitStatus;
    method join (line 45) | async fn join(&self) -> ActorExitStatus;
    method is_disconnected (line 50) | fn is_disconnected(&self) -> bool {
    method any (line 56) | fn any(&self) -> &dyn Any {
    method actor_instance_id (line 59) | fn actor_instance_id(&self) -> &str {
    method observe (line 62) | async fn observe(&self) -> Option<JsonValue> {
    method quit (line 69) | async fn quit(&self) -> ActorExitStatus {
    method join (line 76) | async fn join(&self) -> ActorExitStatus {
  type ActorRegistry (line 82) | pub(crate) struct ActorRegistry {
    method register (line 119) | pub fn register<A: Actor>(&self, mailbox: &Mailbox<A>, join_handle: Ac...
    method observe (line 136) | pub async fn observe(&self, timeout: Duration) -> Vec<ActorObservation> {
    method get (line 162) | pub fn get<A: Actor>(&self) -> Vec<Mailbox<A>> {
    method get_one (line 167) | pub fn get_one<A: Actor>(&self) -> Option<Mailbox<A>> {
    method gc (line 172) | fn gc(&self) {
    method quit (line 178) | pub async fn quit(&self) -> HashMap<String, ActorExitStatus> {
    method is_empty (line 192) | pub fn is_empty(&self) -> bool {
  type ActorRegistryForSpecificType (line 86) | struct ActorRegistryForSpecificType {
    method for_type (line 92) | fn for_type<A>() -> ActorRegistryForSpecificType {
    method gc (line 99) | fn gc(&mut self) {
  type ActorObservation (line 112) | pub struct ActorObservation {
  function get_iter (line 206) | fn get_iter<A: Actor>(
  type ActorJoinHandle (line 226) | pub(crate) struct ActorJoinHandle {
    method new (line 231) | pub(crate) fn new(join_handle: JoinHandle<ActorExitStatus>) -> Self {
    method inner_join (line 237) | async fn inner_join(join_handle: JoinHandle<ActorExitStatus>) -> Actor...
    method join (line 249) | pub(crate) async fn join(&self) -> ActorExitStatus {
  function test_registry (line 262) | async fn test_registry() {
  function test_registry_killed_actor (line 271) | async fn test_registry_killed_actor() {
  function test_registry_last_mailbox_dropped_actor (line 280) | async fn test_registry_last_mailbox_dropped_actor() {
  function test_get_actor_states (line 290) | async fn test_get_actor_states() {

FILE: quickwit/quickwit-actors/src/scheduler.rs
  type Callback (line 27) | type Callback = Box<dyn FnOnce() + Sync + Send + 'static>;
  type TimeoutEvent (line 29) | struct TimeoutEvent {
  method eq (line 36) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 44) | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
  method cmp (line 50) | fn cmp(&self, other: &Self) -> std::cmp::Ordering {
  type SchedulerMessage (line 57) | enum SchedulerMessage {
  type SchedulerClient (line 66) | pub struct SchedulerClient {
    method time_is_accelerated (line 78) | fn time_is_accelerated(&self) -> bool {
    method is_advance_time_forbidden (line 83) | fn is_advance_time_forbidden(&self) -> bool {
    method schedule_event (line 96) | pub fn schedule_event<F: FnOnce() + Send + Sync + 'static>(
    method inc_no_advance_time (line 108) | pub(crate) fn inc_no_advance_time(&self) {
    method dec_no_advance_time (line 117) | pub(crate) fn dec_no_advance_time(&self) {
    method accelerate_time (line 130) | pub fn accelerate_time(&self) {
    method sleep (line 135) | pub async fn sleep(&self, duration: Duration) {
    method timeout (line 146) | pub async fn timeout<O>(
    method process_time (line 164) | pub(crate) fn process_time(&self) {
    method no_advance_time_guard (line 170) | pub fn no_advance_time_guard(&self) -> NoAdvanceTimeGuard {
  type SchedulerClientInner (line 70) | struct SchedulerClientInner {
  type NoAdvanceTimeGuard (line 175) | pub struct NoAdvanceTimeGuard {
    method new (line 180) | fn new(scheduler_client: SchedulerClient) -> Self {
  method drop (line 187) | fn drop(&mut self) {
  function start_scheduler (line 192) | pub fn start_scheduler() -> SchedulerClient {
  type Scheduler (line 218) | struct Scheduler {
    method process_time (line 238) | fn process_time(&mut self) {
    method process_schedule (line 257) | fn process_schedule(&mut self, callback: Callback, timeout: Duration) {
    method scheduler_client (line 264) | fn scheduler_client(&self) -> Option<SchedulerClient> {
    method schedule_next_timeout (line 272) | fn schedule_next_timeout(&mut self) {
    method new (line 308) | pub fn new(scheduler_client: &SchedulerClient) -> Self {
    method advance_time_if_necessary (line 324) | fn advance_time_if_necessary(&mut self) {
    method next_event_deadline (line 343) | fn next_event_deadline(&self) -> Option<Instant> {
    method simulated_now (line 347) | fn simulated_now(&self) -> Instant {
    method timeout_event (line 351) | fn timeout_event(&mut self, deadline: Instant, callback: Callback) -> ...
  type ClockActor (line 372) | struct ClockActor {
    type Reply (line 391) | type Reply = ();
    method handle (line 393) | async fn handle(
  type Tick (line 377) | struct Tick;
  type ObservableState (line 381) | type ObservableState = ();
  method observable_state (line 382) | fn observable_state(&self) -> Self::ObservableState {}
  method initialize (line 384) | async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(), A...
  function test_scheduler_advance_time_fast_forward_initialize (line 405) | async fn test_scheduler_advance_time_fast_forward_initialize() {
  function test_scheduler_advance_time_fast_forward_scheduled_message (line 420) | async fn test_scheduler_advance_time_fast_forward_scheduled_message() {

FILE: quickwit/quickwit-actors/src/spawn_builder.rs
  type SpawnContext (line 34) | pub struct SpawnContext {
    method new (line 41) | pub fn new(scheduler_client: SchedulerClient) -> Self {
    method spawn_builder (line 49) | pub fn spawn_builder<A: Actor>(&self) -> SpawnBuilder<A> {
    method create_mailbox (line 53) | pub fn create_mailbox<A: Actor>(
    method child_context (line 65) | pub fn child_context(&self) -> SpawnContext {
    method schedule_event (line 79) | pub fn schedule_event<F: FnOnce() + Send + Sync + 'static>(
  type SpawnBuilder (line 90) | pub struct SpawnBuilder<A: Actor> {
  function new (line 98) | pub(crate) fn new(spawn_ctx: SpawnContext) -> Self {
  function set_kill_switch (line 110) | pub fn set_kill_switch(mut self, kill_switch: KillSwitch) -> Self {
  function set_mailboxes (line 122) | pub fn set_mailboxes(mut self, mailbox: Mailbox<A>, inbox: Inbox<A>) -> ...
  function set_backpressure_micros_counter (line 132) | pub fn set_backpressure_micros_counter(
  function take_or_create_mailboxes (line 140) | fn take_or_create_mailboxes(&mut self, actor: &A) -> (Mailbox<A>, Inbox<...
  function create_actor_context_and_inbox (line 149) | fn create_actor_context_and_inbox(
  function spawn (line 170) | pub fn spawn(self, actor: A) -> (Mailbox<A>, ActorHandle<A>) {
  function supervise_fn (line 190) | pub fn supervise_fn<F: Fn() -> A + Send + 'static>(
  function supervise (line 209) | pub fn supervise(self, actor: A) -> (Mailbox<A>, ActorHandle<Supervisor<...
  function supervise_default (line 215) | pub fn supervise_default(self) -> (Mailbox<A>, ActorHandle<Supervisor<A>...
  type ActorExitPhase (line 220) | enum ActorExitPhase {
    method fmt (line 229) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function recv_envelope (line 247) | async fn recv_envelope<A: Actor>(inbox: &mut Inbox<A>, ctx: &ActorContex...
  function try_recv_envelope (line 259) | fn try_recv_envelope<A: Actor>(inbox: &mut Inbox<A>) -> Option<Envelope<...
  type ActorExecutionEnv (line 263) | struct ActorExecutionEnv<A: Actor> {
  function initialize (line 270) | async fn initialize(&mut self) -> Result<(), ActorExitStatus> {
  function process_messages (line 274) | async fn process_messages(&mut self) -> (ActorExitStatus, ActorExitPhase) {
  function process_one_message (line 282) | async fn process_one_message(
  function yield_and_check_if_killed (line 296) | async fn yield_and_check_if_killed(&mut self) -> Result<(), (ActorExitSt...
  function process_all_available_messages (line 311) | async fn process_all_available_messages(
  function finalize (line 354) | async fn finalize(&mut self, exit_status: ActorExitStatus) -> ActorExitS...
  method drop (line 377) | fn drop(&mut self) {
  function actor_loop (line 382) | async fn actor_loop<A: Actor>(

FILE: quickwit/quickwit-actors/src/supervisor.rs
  type SupervisorMetrics (line 23) | pub struct SupervisorMetrics {
  type SupervisorState (line 30) | pub struct SupervisorState<S> {
  method default (line 36) | fn default() -> Self {
  type Supervisor (line 44) | pub struct Supervisor<A: Actor> {
  type SuperviseLoop (line 53) | struct SuperviseLoop;
  type ObservableState (line 57) | type ObservableState = SupervisorState<A::ObservableState>;
  method observable_state (line 59) | fn observable_state(&self) -> Self::ObservableState {
  method name (line 70) | fn name(&self) -> String {
  method queue_capacity (line 74) | fn queue_capacity(&self) -> crate::QueueCapacity {
  method initialize (line 78) | async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(), A...
  method finalize (line 83) | async fn finalize(
  function new (line 110) | pub(crate) fn new(
  function supervise (line 125) | async fn supervise(
  type Reply (line 188) | type Reply = ();
  function handle (line 190) | async fn handle(
  type FailingActorMessage (line 213) | enum FailingActorMessage {
  type FailingActor (line 221) | struct FailingActor {
    type Reply (line 249) | type Reply = usize;
    method handle (line 251) | async fn handle(
  type ObservableState (line 227) | type ObservableState = usize;
  method name (line 229) | fn name(&self) -> String {
  method observable_state (line 233) | fn observable_state(&self) -> Self::ObservableState {
  method finalize (line 237) | async fn finalize(
  function test_supervisor_restart_on_panic (line 277) | async fn test_supervisor_restart_on_panic() {
  function test_supervisor_restart_on_error (line 310) | async fn test_supervisor_restart_on_error() {
  function test_supervisor_kills_and_restart_frozen_actor (line 342) | async fn test_supervisor_kills_and_restart_frozen_actor() {
  function test_supervisor_forwards_quit_commands (line 387) | async fn test_supervisor_forwards_quit_commands() {
  function test_supervisor_forwards_kill_command (line 407) | async fn test_supervisor_forwards_kill_command() {
  function test_supervisor_exits_successfully_when_supervised_actor_mailbox_is_dropped (line 429) | async fn test_supervisor_exits_successfully_when_supervised_actor_mailbo...
  function test_supervisor_state (line 440) | async fn test_supervisor_state() {

FILE: quickwit/quickwit-actors/src/tests.rs
  type PingReceiverActor (line 32) | pub struct PingReceiverActor {
    type Reply (line 53) | type Reply = ();
    method handle (line 55) | async fn handle(
  type ObservableState (line 37) | type ObservableState = usize;
  method name (line 39) | fn name(&self) -> String {
  method observable_state (line 43) | fn observable_state(&self) -> Self::ObservableState {
  type Ping (line 49) | pub struct Ping;
  type PingerSenderActor (line 67) | pub struct PingerSenderActor {
    type Reply (line 98) | type Reply = ();
    method handle (line 100) | async fn handle(
    type Reply (line 115) | type Reply = ();
    method handle (line 117) | async fn handle(
  type SenderState (line 73) | pub struct SenderState {
  type AddPeer (line 79) | pub struct AddPeer(Mailbox<PingReceiverActor>);
  type ObservableState (line 82) | type ObservableState = SenderState;
  method name (line 84) | fn name(&self) -> String {
  method observable_state (line 88) | fn observable_state(&self) -> Self::ObservableState {
  function test_actor_stops_when_last_mailbox_is_dropped (line 130) | async fn test_actor_stops_when_last_mailbox_is_dropped() {
  function test_ping_actor (line 141) | async fn test_ping_actor() {
  type BuggyActor (line 215) | struct BuggyActor;
    type Reply (line 235) | type Reply = ();
    method handle (line 237) | async fn handle(
    type Reply (line 248) | type Reply = ();
    method handle (line 250) | async fn handle(
  type DoNothing (line 218) | struct DoNothing;
  type Block (line 221) | struct Block;
  type ObservableState (line 224) | type ObservableState = ();
  method name (line 226) | fn name(&self) -> String {
  method observable_state (line 230) | fn observable_state(&self) {}
  function test_timeouting_actor (line 263) | async fn test_timeouting_actor() {
  function test_pause_actor (line 290) | async fn test_pause_actor() {
  function test_actor_running_states (line 317) | async fn test_actor_running_states() {
  type LoopingActor (line 333) | struct LoopingActor {
    type Reply (line 363) | type Reply = ();
    method handle (line 364) | async fn handle(
    type Reply (line 377) | type Reply = ();
    method handle (line 379) | async fn handle(
  type Loop (line 339) | struct Loop;
  type SingleShot (line 342) | struct SingleShot;
  type ObservableState (line 346) | type ObservableState = Self;
  method observable_state (line 348) | fn observable_state(&self) -> Self::ObservableState {
  method yield_after_each_message (line 352) | fn yield_after_each_message(&self) -> bool {
  method initialize (line 356) | async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(), A...
  function test_looping (line 390) | async fn test_looping() -> anyhow::Result<()> {
  type SummingActor (line 405) | struct SummingActor {
    type Reply (line 411) | type Reply = ();
    method handle (line 413) | async fn handle(&mut self, add: u64, _ctx: &ActorContext<Self>) -> Res...
  type ObservableState (line 420) | type ObservableState = u64;
  method observable_state (line 422) | fn observable_state(&self) -> Self::ObservableState {
  type SpawningActor (line 428) | struct SpawningActor {
    type Reply (line 456) | type Reply = ();
    method handle (line 458) | async fn handle(
  type ObservableState (line 435) | type ObservableState = u64;
  method observable_state (line 437) | fn observable_state(&self) -> Self::ObservableState {
  method finalize (line 441) | async fn finalize(
  function test_actor_spawning_actor (line 472) | async fn test_actor_spawning_actor() -> anyhow::Result<()> {
  type BuggyFinalizeActor (line 485) | struct BuggyFinalizeActor;
  type ObservableState (line 489) | type ObservableState = ();
  method name (line 491) | fn name(&self) -> String {
  method observable_state (line 495) | fn observable_state(&self) {}
  method finalize (line 497) | async fn finalize(
  function test_actor_finalize_error_set_exit_status_to_panicked (line 507) | async fn test_actor_finalize_error_set_exit_status_to_panicked() -> anyh...
  type Adder (line 518) | struct Adder(u64);
    type Reply (line 537) | type Reply = u64;
    method handle (line 539) | async fn handle(
  type ObservableState (line 521) | type ObservableState = u64;
  method yield_after_each_message (line 523) | fn yield_after_each_message(&self) -> bool {
  method observable_state (line 527) | fn observable_state(&self) -> Self::ObservableState {
  type AddOperand (line 533) | struct AddOperand(u64);
  function test_actor_return_response (line 550) | async fn test_actor_return_response() -> anyhow::Result<()> {
  type TestActorWithDrain (line 563) | struct TestActorWithDrain {
    type Reply (line 592) | type Reply = ();
    method handle (line 594) | async fn handle(
  type ProcessAndDrainCounts (line 568) | struct ProcessAndDrainCounts {
  type ObservableState (line 575) | type ObservableState = ProcessAndDrainCounts;
  method observable_state (line 577) | fn observable_state(&self) -> ProcessAndDrainCounts {
  method on_drained_messages (line 581) | async fn on_drained_messages(
  function test_drain_is_called (line 605) | async fn test_drain_is_called() {
  function test_unsync_actor (line 643) | async fn test_unsync_actor() {
  function test_unsync_actor_message (line 679) | async fn test_unsync_actor_message() {
  type FakeActorService (line 728) | struct FakeActorService {
    type Reply (line 744) | type Reply = String;
    method handle (line 746) | async fn handle(
  type GetCoolId (line 734) | struct GetCoolId;
  type ObservableState (line 737) | type ObservableState = ();
  method observable_state (line 739) | fn observable_state(&self) {}
  method default (line 756) | fn default() -> Self {
  function test_get_or_spawn (line 764) | async fn test_get_or_spawn() {

FILE: quickwit/quickwit-actors/src/universe.rs
  type Universe (line 31) | pub struct Universe {
    method new (line 43) | pub fn new() -> Universe {
    method with_accelerated_time (line 58) | pub fn with_accelerated_time() -> Universe {
    method spawn_ctx (line 64) | pub fn spawn_ctx(&self) -> &SpawnContext {
    method create_test_mailbox (line 68) | pub fn create_test_mailbox<A: Actor>(&self) -> (Mailbox<A>, Inbox<A>) {
    method create_mailbox (line 72) | pub fn create_mailbox<A: Actor>(
    method get (line 80) | pub fn get<A: Actor>(&self) -> Vec<Mailbox<A>> {
    method get_one (line 84) | pub fn get_one<A: Actor>(&self) -> Option<Mailbox<A>> {
    method get_or_spawn_one (line 88) | pub fn get_or_spawn_one<A: Actor + Default>(&self) -> Mailbox<A> {
    method observe (line 98) | pub async fn observe(&self, timeout: Duration) -> Vec<ActorObservation> {
    method kill (line 102) | pub fn kill(&self) {
    method sleep (line 111) | pub async fn sleep(&self, duration: Duration) {
    method spawn_builder (line 115) | pub fn spawn_builder<A: Actor>(&self) -> SpawnBuilder<A> {
    method send_exit_with_success (line 121) | pub async fn send_exit_with_success<A: Actor>(
    method quit (line 130) | pub async fn quit(&self) -> HashMap<String, ActorExitStatus> {
    method assert_quit (line 138) | pub async fn assert_quit(self) {
  method default (line 36) | fn default() -> Universe {
  method drop (line 150) | fn drop(&mut self) {
  type CountingMinutesActor (line 174) | pub struct CountingMinutesActor {
    type Reply (line 196) | type Reply = ();
    method handle (line 197) | async fn handle(
  type ObservableState (line 180) | type ObservableState = usize;
  method observable_state (line 182) | fn observable_state(&self) -> usize {
  method initialize (line 186) | async fn initialize(&mut self, ctx: &ActorContext<Self>) -> Result<(), A...
  type Loop (line 192) | struct Loop;
  type ExitPanickingActor (line 209) | pub struct ExitPanickingActor {}
  type ObservableState (line 213) | type ObservableState = ();
  method observable_state (line 215) | fn observable_state(&self) -> Self::ObservableState {}
  method drop (line 219) | fn drop(&mut self) {
  function test_schedule_for_actor (line 225) | async fn test_schedule_for_actor() {
  function test_actor_quit_after_universe_quit (line 238) | async fn test_actor_quit_after_universe_quit() {
  function test_universe_join_after_actor_quit (line 253) | async fn test_universe_join_after_actor_quit() {
  function test_universe_quit_with_panicking_actor (line 268) | async fn test_universe_quit_with_panicking_actor() {
  function test_enforce_universe_assert_quit_calls (line 288) | async fn test_enforce_universe_assert_quit_calls() {

FILE: quickwit/quickwit-aws/src/error.rs
  method is_retryable (line 34) | fn is_retryable(&self) -> bool {
  function is_retryable (line 46) | fn is_retryable(meta: &aws_sdk_s3::error::ErrorMetadata) -> bool {
  method is_retryable (line 58) | fn is_retryable(&self) -> bool {
  method is_retryable (line 64) | fn is_retryable(&self) -> bool {
  method is_retryable (line 70) | fn is_retryable(&self) -> bool {
  method is_retryable (line 76) | fn is_retryable(&self) -> bool {
  method is_retryable (line 82) | fn is_retryable(&self) -> bool {
  method is_retryable (line 88) | fn is_retryable(&self) -> bool {
  method is_retryable (line 94) | fn is_retryable(&self) -> bool {
  method is_retryable (line 100) | fn is_retryable(&self) -> bool {
  method is_retryable (line 106) | fn is_retryable(&self) -> bool {
  method is_retryable (line 126) | fn is_retryable(&self) -> bool {
  method is_retryable (line 136) | fn is_retryable(&self) -> bool {
  method is_retryable (line 145) | fn is_retryable(&self) -> bool {
  method is_retryable (line 155) | fn is_retryable(&self) -> bool {
  method is_retryable (line 165) | fn is_retryable(&self) -> bool {
  method is_retryable (line 175) | fn is_retryable(&self) -> bool {
  method is_retryable (line 181) | fn is_retryable(&self) -> bool {
  method is_retryable (line 187) | fn is_retryable(&self) -> bool {
  method is_retryable (line 197) | fn is_retryable(&self) -> bool {
  method is_retryable (line 216) | fn is_retryable(&self) -> bool {
  method is_retryable (line 222) | fn is_retryable(&self) -> bool {
  method is_retryable (line 228) | fn is_retryable(&self) -> bool {

FILE: quickwit/quickwit-aws/src/lib.rs
  constant DEFAULT_AWS_REGION (line 24) | pub const DEFAULT_AWS_REGION: Region = Region::from_static("us-east-1");
  function get_aws_config (line 27) | pub async fn get_aws_config() -> &'static aws_config::SdkConfig {
  function aws_behavior_version (line 44) | pub fn aws_behavior_version() -> BehaviorVersion {

FILE: quickwit/quickwit-aws/src/retry.rs
  type AwsRetryable (line 22) | pub trait AwsRetryable {
    method is_retryable (line 23) | fn is_retryable(&self) -> bool {
    method is_retryable (line 29) | fn is_retryable(&self) -> bool {
  type AwsRetryableWrapper (line 38) | struct AwsRetryableWrapper<E>(E);
  method is_retryable (line 43) | fn is_retryable(&self) -> bool {
  function aws_retry (line 48) | pub async fn aws_retry<U, E, Fut>(retry_params: &RetryParams, f: impl Fn...

FILE: quickwit/quickwit-cli/src/checklist.rs
  constant BLUE_COLOR (line 22) | pub const BLUE_COLOR: Color = Color::TrueColor {
  constant GREEN_COLOR (line 28) | pub const GREEN_COLOR: Color = Color::Green;
  constant WHITE_COLOR (line 29) | pub const WHITE_COLOR: Color = Color::TrueColor {
  constant RED_COLOR (line 34) | pub const RED_COLOR: Color = Color::TrueColor {
  function print_checklist (line 40) | pub fn print_checklist(check_list_results: &[(&str, anyhow::Result<()>)]) {
  function run_checklist (line 82) | pub fn run_checklist(checks: Vec<(&str, anyhow::Result<()>)>) -> Result<...
  type ChecklistError (line 95) | pub struct ChecklistError {
    method from_results (line 100) | pub fn from_results(results: Vec<(&str, anyhow::Result<()>)>) -> Self {
  method fmt (line 111) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

FILE: quickwit/quickwit-cli/src/cli.rs
  function build_cli (line 26) | pub fn build_cli() -> Command {
  type CliCommand (line 56) | pub enum CliCommand {
    method default_log_level (line 65) | pub fn default_log_level(&self) -> Level {
    method parse_cli_args (line 75) | pub fn parse_cli_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method execute (line 89) | pub async fn execute(self, env_filter_reload_fn: EnvFilterReloadFn) ->...

FILE: quickwit/quickwit-cli/src/generate_markdown.rs
  function main (line 21) | async fn main() -> anyhow::Result<()> {
  function markdown_for_command (line 31) | fn markdown_for_command(command: &Command, doc_extensions: &toml::Value) {
  function markdown_for_subcommand (line 37) | fn markdown_for_subcommand(
  function markdown_for_command_helper (line 65) | fn markdown_for_command_helper(
  function generate_markdown_from_clap (line 176) | fn generate_markdown_from_clap(command: &Command) {

FILE: quickwit/quickwit-cli/src/index.rs
  function build_index_command (line 50) | pub fn build_index_command() -> Command {
  type ClearIndexArgs (line 199) | pub struct ClearIndexArgs {
  type CreateIndexArgs (line 206) | pub struct CreateIndexArgs {
  type UpdateIndexArgs (line 214) | pub struct UpdateIndexArgs {
  type DescribeIndexArgs (line 223) | pub struct DescribeIndexArgs {
  type IngestDocsArgs (line 229) | pub struct IngestDocsArgs {
  type SearchIndexArgs (line 239) | pub struct SearchIndexArgs {
  type DeleteIndexArgs (line 254) | pub struct DeleteIndexArgs {
  type ListIndexesArgs (line 262) | pub struct ListIndexesArgs {
  type IndexCliCommand (line 267) | pub enum IndexCliCommand {
    method default_log_level (line 279) | pub fn default_log_level(&self) -> Level {
    method parse_cli_args (line 286) | pub fn parse_cli_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_clear_args (line 303) | fn parse_clear_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_create_args (line 316) | fn parse_create_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_update_args (line 333) | fn parse_update_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_describe_args (line 354) | fn parse_describe_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_list_args (line 366) | fn parse_list_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_ingest_args (line 371) | fn parse_ingest_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_search_args (line 410) | fn parse_search_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_delete_args (line 458) | fn parse_delete_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method execute (line 473) | pub async fn execute(self) -> anyhow::Result<()> {
  function clear_index_cli (line 487) | pub async fn clear_index_cli(args: ClearIndexArgs) -> anyhow::Result<()> {
  function create_index_cli (line 505) | pub async fn create_index_cli(args: CreateIndexArgs) -> anyhow::Result<(...
  function update_index_cli (line 534) | pub async fn update_index_cli(args: UpdateIndexArgs) -> anyhow::Result<(...
  function list_index_cli (line 568) | pub async fn list_index_cli(args: ListIndexesArgs) -> anyhow::Result<()> {
  function make_list_indexes_table (line 581) | fn make_list_indexes_table<I>(indexes: I) -> Table
  type IndexRow (line 594) | struct IndexRow {
  function describe_index_cli (line 601) | pub async fn describe_index_cli(args: DescribeIndexArgs) -> anyhow::Resu...
  type IndexStats (line 615) | pub struct IndexStats {
    method from_metadata (line 707) | pub fn from_metadata(
    method display_as_table (line 783) | pub fn display_as_table(&self) -> String {
  constant LENGTH (line 629) | const LENGTH: usize = 9;
  method fields (line 631) | fn fields(&self) -> Vec<Cow<'_, str>> {
  method headers (line 654) | fn headers() -> Vec<Cow<'static, str>> {
  function format_to_si_scale (line 672) | fn format_to_si_scale(num: impl numfmt::Numeric) -> String {
  function separate_thousands (line 677) | fn separate_thousands(num: impl numfmt::Numeric) -> String {
  function display_option_in_table (line 687) | fn display_option_in_table(opt: &Option<impl Display>) -> String {
  function display_timestamp (line 694) | fn display_timestamp(timestamp: &Option<i64>) -> String {
  function create_table (line 808) | fn create_table(table: impl Tabled, header: &str, is_vertical: bool) -> ...
  type DescriptiveStats (line 838) | pub struct DescriptiveStats {
    method into_table (line 844) | pub fn into_table(self, header: &str) -> Table {
    method maybe_new (line 917) | pub fn maybe_new(values: &[u64]) -> Option<DescriptiveStats> {
  type Output (line 862) | type Output = DescriptiveStats;
  function div (line 864) | fn div(self, rhs: f32) -> Self::Output {
  type SummaryStats (line 873) | pub struct SummaryStats {
    type Output (line 881) | type Output = Self;
    method div (line 883) | fn div(self, rhs: f32) -> Self::Output {
  type Quantiles (line 894) | pub struct Quantiles {
    type Output (line 903) | type Output = Self;
    method div (line 905) | fn div(self, rhs: f32) -> Self::Output {
  constant LENGTH (line 941) | const LENGTH: usize = 4;
  method fields (line 943) | fn fields(&self) -> Vec<Cow<'_, str>> {
  method headers (line 955) | fn headers() -> Vec<Cow<'static, str>> {
  constant LENGTH (line 969) | const LENGTH: usize = 5;
  method fields (line 971) | fn fields(&self) -> Vec<Cow<'_, str>> {
  method headers (line 984) | fn headers() -> Vec<Cow<'static, str>> {
  function ingest_docs_cli (line 998) | pub async fn ingest_docs_cli(args: IngestDocsArgs) -> anyhow::Result<()> {
  function progress_bar_style (line 1089) | fn progress_bar_style() -> ProgressStyle {
  function search_index (line 1097) | pub async fn search_index(args: SearchIndexArgs) -> anyhow::Result<Searc...
  function search_index_cli (line 1132) | pub async fn search_index_cli(args: SearchIndexArgs) -> anyhow::Result<(...
  function delete_index_cli (line 1140) | pub async fn delete_index_cli(args: DeleteIndexArgs) -> anyhow::Result<(...
  function split_metadata_for_test (line 1183) | pub fn split_metadata_for_test(
  function test_index_stats (line 1197) | fn test_index_stats() -> anyhow::Result<()> {
  function test_descriptive_stats (line 1246) | fn test_descriptive_stats() -> anyhow::Result<()> {

FILE: quickwit/quickwit-cli/src/jemalloc.rs
  constant JEMALLOC_METRICS_POLLING_INTERVAL (line 30) | const JEMALLOC_METRICS_POLLING_INTERVAL: Duration = Duration::from_secs(1);
  function jemalloc_metrics_loop (line 32) | pub async fn jemalloc_metrics_loop() -> tikv_jemalloc_ctl::Result<()> {
  function start_jemalloc_metrics_loop (line 61) | pub fn start_jemalloc_metrics_loop() {

FILE: quickwit/quickwit-cli/src/lib.rs
  constant THROUGHPUT_WINDOW_SIZE (line 61) | const THROUGHPUT_WINDOW_SIZE: usize = 5;
  constant QW_ENABLE_TOKIO_CONSOLE_ENV_KEY (line 63) | pub const QW_ENABLE_TOKIO_CONSOLE_ENV_KEY: &str = "QW_ENABLE_TOKIO_CONSO...
  constant QW_ENABLE_OPENTELEMETRY_OTLP_EXPORTER_ENV_KEY (line 65) | pub const QW_ENABLE_OPENTELEMETRY_OTLP_EXPORTER_ENV_KEY: &str =
  function config_cli_arg (line 68) | fn config_cli_arg() -> Arg {
  function client_args (line 78) | fn client_args() -> Vec<Arg> {
  function install_default_crypto_ring_provider (line 111) | pub fn install_default_crypto_ring_provider() {
  type ClientArgs (line 123) | pub struct ClientArgs {
    method client_builder (line 144) | pub fn client_builder(self) -> QuickwitClientBuilder {
    method client (line 160) | pub fn client(self) -> QuickwitClient {
    method parse_for_ingest (line 164) | pub fn parse_for_ingest(matches: &mut ArgMatches) -> anyhow::Result<Se...
    method parse (line 168) | pub fn parse(matches: &mut ArgMatches) -> anyhow::Result<Self> {
    method parse_inner (line 172) | fn parse_inner(matches: &mut ArgMatches, process_ingest: bool) -> anyh...
  method default (line 132) | fn default() -> Self {
  function parse_duration_or_none (line 211) | pub fn parse_duration_or_none(duration_with_unit_str: &str) -> anyhow::R...
  function start_actor_runtimes (line 221) | pub fn start_actor_runtimes(
  function load_node_config (line 236) | async fn load_node_config(config_uri: &Uri) -> anyhow::Result<NodeConfig> {
  function get_resolvers (line 248) | fn get_resolvers(
  function run_index_checklist (line 269) | pub async fn run_index_checklist(
  function make_table (line 314) | pub fn make_table<T: Tabled>(
  function prompt_confirmation (line 336) | fn prompt_confirmation(prompt: &str, default: bool) -> bool {
  constant ALLOWED_DELAY_MICROS (line 363) | const ALLOWED_DELAY_MICROS: u64 = 5000;
  constant DEBUG_SUPPRESSION_MICROS (line 364) | const DEBUG_SUPPRESSION_MICROS: u64 = 30_000_000;
  function set_enabled (line 372) | pub fn set_enabled(enabled: bool) {
  function thread_unpark (line 376) | pub fn thread_unpark() {
  function thread_park (line 385) | pub fn thread_park() {
  function emit_debug (line 406) | fn emit_debug(delta: u64, now: u64) {
  function test_parse_duration_or_none (line 443) | fn test_parse_duration_or_none() -> anyhow::Result<()> {
  function test_get_resolvers (line 454) | fn test_get_resolvers() {

FILE: quickwit/quickwit-cli/src/logger.rs
  function startup_env_filter (line 47) | fn startup_env_filter(level: Level) -> anyhow::Result<EnvFilter> {
  type ReloadLayer (line 55) | type ReloadLayer = tracing_subscriber::reload::Layer<EnvFilter, tracing_...
  function setup_logging_and_tracing (line 57) | pub fn setup_logging_and_tracing(
  function time_formatter (line 166) | fn time_formatter() -> UtcTime<Vec<BorrowedFormatItem<'static>>> {
  type EventFormat (line 174) | enum EventFormat<'a> {
  function get_from_env (line 182) | fn get_from_env() -> Self {
  function format_fields (line 198) | fn format_fields(&self) -> FieldFormat {
  function format_event (line 211) | fn format_event(
  type FieldFormat (line 224) | enum FieldFormat {
    method format_fields (line 230) | fn format_fields<R: RecordFields>(&self, writer: Writer<'_>, fields: R...
  type ProfilingFormat (line 264) | struct ProfilingFormat {
    method format_event (line 281) | fn format_event(
  method default (line 269) | fn default() -> Self {
  function profiler_tracing_filter (line 327) | fn profiler_tracing_filter(metadata: &Metadata) -> bool {
  function configure_registry (line 338) | pub(super) fn configure_registry<S>(

FILE: quickwit/quickwit-cli/src/main.rs
  function get_main_runtime_num_threads (line 33) | fn get_main_runtime_num_threads() -> usize {
  function main (line 42) | fn main() -> anyhow::Result<()> {
  function register_build_info_metric (line 58) | fn register_build_info_metric() {
  function main_impl (line 73) | async fn main_impl() -> anyhow::Result<()> {
  function about_text (line 129) | fn about_text() -> String {
  function test_parse_clear_args (line 163) | fn test_parse_clear_args() {
  function test_parse_create_args (line 190) | fn test_parse_create_args() -> anyhow::Result<()> {
  function test_parse_ingest_args (line 234) | fn test_parse_ingest_args() -> anyhow::Result<()> {
  function test_parse_local_ingest_args (line 406) | fn test_parse_local_ingest_args() {
  function test_parse_search_args (line 446) | fn test_parse_search_args() -> anyhow::Result<()> {
  function test_parse_local_search_args (line 519) | fn test_parse_local_search_args() {
  function test_parse_delete_args (line 597) | fn test_parse_delete_args() {
  function test_parse_describe_index_args (line 628) | fn test_parse_describe_index_args() {
  function test_parse_split_describe_args (line 644) | fn test_parse_split_describe_args() -> anyhow::Result<()> {
  function test_parse_split_extract_args (line 668) | fn test_parse_split_extract_args() -> anyhow::Result<()> {
  function test_parse_garbage_collect_args (line 696) | fn test_parse_garbage_collect_args() -> anyhow::Result<()> {
  function test_parse_merge_args (line 744) | fn test_parse_merge_args() -> anyhow::Result<()> {
  function test_parse_no_color (line 769) | fn test_parse_no_color() {

FILE: quickwit/quickwit-cli/src/metrics.rs
  type CliMetrics (line 18) | pub struct CliMetrics {
  method default (line 23) | fn default() -> Self {

FILE: quickwit/quickwit-cli/src/service.rs
  function build_run_command (line 36) | pub fn build_run_command() -> Command {
  type RunCliCommand (line 49) | pub struct RunCliCommand {
    method parse_cli_args (line 87) | pub fn parse_cli_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method execute (line 108) | pub async fn execute(&self, env_filter_reload_fn: EnvFilterReloadFn) -...
  function listen_interrupt (line 54) | async fn listen_interrupt() {
  function listen_sigterm (line 78) | async fn listen_sigterm() {
  function quickwit_telemetry_info (line 154) | fn quickwit_telemetry_info(config: &NodeConfig) -> QuickwitTelemetryInfo {
  function test_parse_service_run_args_all_services (line 186) | fn test_parse_service_run_args_all_services() -> anyhow::Result<()> {
  function test_parse_service_run_args_indexer_only (line 204) | fn test_parse_service_run_args_indexer_only() -> anyhow::Result<()> {
  function test_parse_service_run_args_searcher_and_metastore (line 228) | fn test_parse_service_run_args_searcher_and_metastore() -> anyhow::Resul...
  function test_parse_service_run_indexer_only_args (line 256) | fn test_parse_service_run_indexer_only_args() -> anyhow::Result<()> {

FILE: quickwit/quickwit-cli/src/source.rs
  function build_source_command (line 33) | pub fn build_source_command() -> Command {
  type CreateSourceArgs (line 155) | pub struct CreateSourceArgs {
  type UpdateSourceArgs (line 162) | pub struct UpdateSourceArgs {
  type ToggleSourceArgs (line 171) | pub struct ToggleSourceArgs {
  type DeleteSourceArgs (line 179) | pub struct DeleteSourceArgs {
  type DescribeSourceArgs (line 187) | pub struct DescribeSourceArgs {
  type ListSourcesArgs (line 194) | pub struct ListSourcesArgs {
  type ResetCheckpointArgs (line 200) | pub struct ResetCheckpointArgs {
  type SourceCliCommand (line 208) | pub enum SourceCliCommand {
    method execute (line 219) | pub async fn execute(self) -> anyhow::Result<()> {
    method parse_cli_args (line 231) | pub fn parse_cli_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_create_args (line 254) | fn parse_create_args(mut matches: ArgMatches) -> anyhow::Result<Create...
    method parse_update_args (line 270) | fn parse_update_args(mut matches: ArgMatches) -> anyhow::Result<Update...
    method parse_toggle_source_args (line 293) | fn parse_toggle_source_args(
    method parse_delete_args (line 313) | fn parse_delete_args(mut matches: ArgMatches) -> anyhow::Result<Delete...
    method parse_describe_args (line 330) | fn parse_describe_args(mut matches: ArgMatches) -> anyhow::Result<Desc...
    method parse_list_args (line 345) | fn parse_list_args(mut matches: ArgMatches) -> anyhow::Result<ListSour...
    method parse_reset_checkpoint_args (line 356) | fn parse_reset_checkpoint_args(mut matches: ArgMatches) -> anyhow::Res...
  function create_source_cli (line 374) | async fn create_source_cli(args: CreateSourceArgs) -> anyhow::Result<()> {
  function update_source_cli (line 391) | async fn update_source_cli(args: UpdateSourceArgs) -> anyhow::Result<()> {
  function toggle_source_cli (line 413) | async fn toggle_source_cli(args: ToggleSourceArgs) -> anyhow::Result<()> {
  function delete_source_cli (line 432) | async fn delete_source_cli(args: DeleteSourceArgs) -> anyhow::Result<()> {
  function describe_source_cli (line 454) | async fn describe_source_cli(args: DescribeSourceArgs) -> anyhow::Result...
  function make_describe_source_tables (line 476) | fn make_describe_source_tables<I>(
  function list_sources_cli (line 513) | async fn list_sources_cli(args: ListSourcesArgs) -> anyhow::Result<()> {
  function make_list_sources_table (line 525) | fn make_list_sources_table<I>(sources: I) -> Table
  type SourceRow (line 539) | struct SourceRow {
  type ParamsRow (line 549) | struct ParamsRow {
  type CheckpointRow (line 557) | struct CheckpointRow {
  function display_tables (line 564) | fn display_tables(tables: &[Table]) {
  function reset_checkpoint_cli (line 571) | async fn reset_checkpoint_cli(args: ResetCheckpointArgs) -> anyhow::Resu...
  function flatten_json (line 597) | fn flatten_json(value: JsonValue) -> Vec<(String, JsonValue)> {
  function test_flatten_json (line 634) | fn test_flatten_json() {
  function test_parse_create_source_args (line 653) | fn test_parse_create_source_args() {
  function test_parse_update_source_args (line 676) | fn test_parse_update_source_args() {
  function test_parse_toggle_source_args (line 703) | fn test_parse_toggle_source_args() {
  function test_parse_delete_source_args (line 751) | fn test_parse_delete_source_args() {
  function test_parse_describe_source_args (line 776) | fn test_parse_describe_source_args() {
  function test_parse_reset_checkpoint_args (line 799) | fn test_parse_reset_checkpoint_args() {
  function test_make_describe_source_tables (line 824) | fn test_make_describe_source_tables() {
  function test_parse_list_sources_args (line 881) | fn test_parse_list_sources_args() {
  function test_make_list_sources_table (line 895) | fn test_make_list_sources_table() {

FILE: quickwit/quickwit-cli/src/split.rs
  function build_split_command (line 31) | pub fn build_split_command() -> Command {
  type OutputFormat (line 107) | enum OutputFormat {
  type Err (line 114) | type Err = anyhow::Error;
  method from_str (line 116) | fn from_str(output_format_str: &str) -> anyhow::Result<Self> {
  type ListSplitArgs (line 130) | pub struct ListSplitArgs {
  type MarkForDeletionArgs (line 144) | pub struct MarkForDeletionArgs {
  type DescribeSplitArgs (line 152) | pub struct DescribeSplitArgs {
  type SplitCliCommand (line 160) | pub enum SplitCliCommand {
    method parse_cli_args (line 167) | pub fn parse_cli_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_list_args (line 179) | fn parse_list_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_mark_for_deletion_args (line 242) | fn parse_mark_for_deletion_args(mut matches: ArgMatches) -> anyhow::Re...
    method parse_describe_args (line 260) | fn parse_describe_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method execute (line 278) | pub async fn execute(self) -> anyhow::Result<()> {
  function list_split_cli (line 287) | async fn list_split_cli(args: ListSplitArgs) -> anyhow::Result<()> {
  function mark_splits_for_deletion_cli (line 316) | async fn mark_splits_for_deletion_cli(args: MarkForDeletionArgs) -> anyh...
  function describe_split_cli (line 338) | async fn describe_split_cli(args: DescribeSplitArgs) -> anyhow::Result<(...
  function make_split_table (line 391) | fn make_split_table(splits: &[Split], title: &str) -> Table {
  function parse_date (line 420) | fn parse_date(date_arg: &str, option_name: &str) -> anyhow::Result<Offse...
  function parse_split_state (line 445) | fn parse_split_state(split_state_arg: &str) -> anyhow::Result<SplitState> {
  type SplitRow (line 459) | struct SplitRow {
  function test_parse_list_split_args (line 485) | fn test_parse_list_split_args() -> anyhow::Result<()> {
  function test_parse_split_mark_for_deletion_args (line 545) | fn test_parse_split_mark_for_deletion_args() -> anyhow::Result<()> {
  function test_parse_split_describe_args (line 575) | fn test_parse_split_describe_args() -> anyhow::Result<()> {
  function test_parse_date (line 599) | fn test_parse_date() {
  function test_parse_split_state (line 623) | fn test_parse_split_state() {

FILE: quickwit/quickwit-cli/src/stats.rs
  function mean (line 15) | pub(crate) fn mean(values: &[u64]) -> f32 {
  function std_deviation (line 21) | pub(crate) fn std_deviation(values: &[u64]) -> f32 {
  function percentile (line 36) | pub(crate) fn percentile(sorted_values: &[u64], percent: usize) -> f32 {

FILE: quickwit/quickwit-cli/src/tool.rs
  function build_tool_command (line 66) | pub fn build_tool_command() -> Command {
  type LocalIngestDocsArgs (line 171) | pub struct LocalIngestDocsArgs {
  type LocalSearchArgs (line 182) | pub struct LocalSearchArgs {
  type GarbageCollectIndexArgs (line 197) | pub struct GarbageCollectIndexArgs {
  type MergeArgs (line 205) | pub struct MergeArgs {
  type ExtractSplitArgs (line 212) | pub struct ExtractSplitArgs {
  type ToolCliCommand (line 220) | pub enum ToolCliCommand {
    method parse_cli_args (line 229) | pub fn parse_cli_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_local_ingest_args (line 243) | fn parse_local_ingest_args(mut matches: ArgMatches) -> anyhow::Result<...
    method parse_local_search_args (line 277) | fn parse_local_search_args(mut matches: ArgMatches) -> anyhow::Result<...
    method parse_merge_args (line 327) | fn parse_merge_args(mut matches: ArgMatches) -> anyhow::Result<Self> {
    method parse_garbage_collect_args (line 345) | fn parse_garbage_collect_args(mut matches: ArgMatches) -> anyhow::Resu...
    method parse_extract_split_args (line 366) | fn parse_extract_split_args(mut matches: ArgMatches) -> anyhow::Result...
    method execute (line 389) | pub async fn execute(self) -> anyhow::Result<()> {
  function local_ingest_docs_cli (line 400) | pub async fn local_ingest_docs_cli(args: LocalIngestDocsArgs) -> anyhow:...
  function local_search_cli (line 530) | pub async fn local_search_cli(args: LocalSearchArgs) -> anyhow::Result<(...
  function merge_cli (line 568) | pub async fn merge_cli(args: MergeArgs) -> anyhow::Result<()> {
  function garbage_collect_index_cli (line 654) | pub async fn garbage_collect_index_cli(args: GarbageCollectIndexArgs) ->...
  function extract_split_cli (line 719) | async fn extract_split_cli(args: ExtractSplitArgs) -> anyhow::Result<()> {
  function start_statistics_reporting_loop (line 753) | pub async fn start_statistics_reporting_loop(
  function colorize_error_rate (line 830) | fn colorize_error_rate(error_rate: f64) -> ColoredString {
  type Printer (line 842) | struct Printer<'a> {
  function print_header (line 847) | pub fn print_header(&mut self, header: &str) -> io::Result<()> {
  function print_value (line 852) | pub fn print_value(&mut self, fmt_args: fmt::Arguments) -> io::Result<()> {
  function flush (line 856) | pub fn flush(&mut self) -> io::Result<()> {
  function display_statistics (line 861) | fn display_statistics(
  type ThroughputCalculator (line 895) | struct ThroughputCalculator {
    method new (line 904) | pub fn new(start_time: Instant) -> Self {
    method calculate (line 915) | pub fn calculate(&mut self, current_processed_bytes: u64) -> f64 {
    method elapsed_time (line 927) | pub fn elapsed_time(&self) -> Duration {
  function create_empty_cluster (line 932) | async fn create_empty_cluster(config: &NodeConfig) -> anyhow::Result<Clu...

FILE: quickwit/quickwit-cli/tests/cli.rs
  function create_logs_index (line 51) | async fn create_logs_index(test_env: &TestEnv) -> anyhow::Result<()> {
  function local_ingest_docs (line 61) | async fn local_ingest_docs(uri: Uri, test_env: &TestEnv) -> anyhow::Resu...
  function local_ingest_log_docs (line 74) | async fn local_ingest_log_docs(test_env: &TestEnv) -> anyhow::Result<()> {
  function test_cmd_help (line 79) | fn test_cmd_help() {
  function test_cmd_create (line 89) | async fn test_cmd_create() {
  function test_cmd_create_no_index_uri (line 107) | async fn test_cmd_create_no_index_uri() {
  function test_cmd_create_overwrite (line 132) | async fn test_cmd_create_overwrite() {
  function test_cmd_create_with_ill_formed_command (line 156) | fn test_cmd_create_with_ill_formed_command() {
  function test_cmd_ingest_on_non_existing_index (line 166) | async fn test_cmd_ingest_on_non_existing_index() {
  function test_ingest_docs_cli_keep_cache (line 193) | async fn test_ingest_docs_cli_keep_cache() {
  function test_ingest_docs_cli (line 219) | async fn test_ingest_docs_cli() {
  function test_reingest_same_file_cli (line 284) | async fn test_reingest_same_file_cli() {
  function assert_flexible_json_eq (line 328) | fn assert_flexible_json_eq(value_json: &serde_json::Value, expected_json...
  function test_cmd_search_aggregation (line 369) | async fn test_cmd_search_aggregation() {
  function test_cmd_search_with_snippets (line 467) | async fn test_cmd_search_with_snippets() -> Result<()> {
  function test_search_index_cli (line 506) | async fn test_search_index_cli() {
  function test_cmd_update_index (line 553) | async fn test_cmd_update_index() {
  function test_delete_index_cli_dry_run (line 596) | async fn test_delete_index_cli_dry_run() {
  function test_delete_index_cli (line 658) | async fn test_delete_index_cli() {
  function test_garbage_collect_cli_no_grace (line 681) | async fn test_garbage_collect_cli_no_grace() {
  function test_garbage_collect_index_cli (line 790) | async fn test_garbage_collect_index_cli() {
  function test_all_local_index (line 932) | async fn test_all_local_index() {
  function test_all_with_s3_localstack_cli (line 982) | async fn test_all_with_s3_localstack_cli() {

FILE: quickwit/quickwit-cli/tests/helpers.rs
  constant PACKAGE_BIN_NAME (line 36) | pub const PACKAGE_BIN_NAME: &str = "quickwit";
  constant DEFAULT_INDEX_CONFIG (line 38) | const DEFAULT_INDEX_CONFIG: &str = r#"
  constant RETENTION_CONFIG (line 78) | const RETENTION_CONFIG: &str = r#"
  constant DEFAULT_QUICKWIT_CONFIG (line 84) | const DEFAULT_QUICKWIT_CONFIG: &str = r#"
  constant LOGS_JSON_DOCS (line 93) | const LOGS_JSON_DOCS: &str = r#"{"event": "foo", "level": "info", "ts": ...
  constant WIKI_JSON_DOCS (line 99) | const WIKI_JSON_DOCS: &str = r#"{"body": "foo", "title": "shimroy", "url...
  type TestResourceFiles (line 106) | pub struct TestResourceFiles {
  type TestEnv (line 115) | pub struct TestEnv {
    method metastore (line 140) | pub async fn metastore(&self) -> MetastoreServiceClient {
    method index_metadata (line 147) | pub async fn index_metadata(&self) -> anyhow::Result<IndexMetadata> {
    method start_server (line 157) | pub async fn start_server(&self) -> anyhow::Result<()> {
    method default_client_args (line 174) | pub fn default_client_args(&self) -> ClientArgs {
  type TestStorageType (line 182) | pub enum TestStorageType {
  function uri_from_path (line 187) | pub fn uri_from_path(path: &Path) -> Uri {
  function create_test_env (line 192) | pub async fn create_test_env(
  function upload_test_file (line 283) | pub async fn upload_test_file(

FILE: quickwit/quickwit-cluster/src/change.rs
  type ClusterChange (line 36) | pub enum ClusterChange {
  type ClusterChangeStream (line 47) | pub struct ClusterChangeStream(#[pin] UnboundedReceiverStream<ClusterCha...
    method new_unbounded (line 50) | pub fn new_unbounded() -> (Self, mpsc::UnboundedSender<ClusterChange>) {
  type Item (line 60) | type Item = ClusterChange;
  method poll_next (line 62) | fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<...
  type ClusterChangeStreamFactory (line 68) | pub trait ClusterChangeStreamFactory: Clone + Send + 'static {
    method create (line 69) | fn create(&self) -> ClusterChangeStream;
    method create (line 352) | fn create(&self) -> ClusterChangeStream {
  function compute_cluster_change_events (line 74) | pub(crate) async fn compute_cluster_change_events(
  function compute_cluster_change_events_on_added (line 136) | async fn compute_cluster_change_events_on_added(
  function compute_cluster_change_events_on_updated (line 203) | async fn compute_cluster_change_events_on_updated(
  function compute_cluster_change_events_on_removed (line 261) | fn compute_cluster_change_events_on_removed(
  function try_new_node_with_channel (line 287) | fn try_new_node_with_channel(
  function try_new_node (line 308) | async fn try_new_node(
  type ClusterChangeStreamFactoryForTest (line 341) | pub struct ClusterChangeStreamFactoryForTest {
    method change_stream_tx (line 346) | pub fn change_stream_tx(&self) -> mpsc::UnboundedSender<ClusterChange> {
  type NodeStateBuilder (line 375) | pub(crate) struct NodeStateBuilder {
    method with_grpc_advertise_addr (line 394) | pub(crate) fn with_grpc_advertise_addr(mut self, grpc_advertise_addr: ...
    method with_readiness (line 399) | pub(crate) fn with_readiness(mut self, readiness: bool) -> Self {
    method with_key_value (line 404) | pub(crate) fn with_key_value(mut self, key: &str, value: &str) -> Self {
    method build (line 409) | pub(crate) fn build(self) -> NodeState {
  method default (line 383) | fn default() -> Self {
  function test_compute_cluster_change_events_on_added (line 439) | async fn test_compute_cluster_change_events_on_added() {
  function test_compute_cluster_change_events_on_updated (line 603) | async fn test_compute_cluster_change_events_on_updated() {
  function test_compute_cluster_change_events_on_removed (line 796) | async fn test_compute_cluster_change_events_on_removed() {
  function test_compute_cluster_change_events (line 902) | async fn test_compute_cluster_change_events() {

FILE: quickwit/quickwit-cluster/src/cluster.rs
  constant MARKED_FOR_DELETION_GRACE_PERIOD (line 49) | const MARKED_FOR_DELETION_GRACE_PERIOD: Duration = if cfg!(any(test, fea...
  constant INDEXING_TASK_PREFIX (line 57) | const INDEXING_TASK_PREFIX: &str = "indexer.task:";
  type Cluster (line 60) | pub struct Cluster {
    method cluster_id (line 90) | pub fn cluster_id(&self) -> &str {
    method self_chitchat_id (line 94) | pub fn self_chitchat_id(&self) -> &ChitchatId {
    method self_node_id (line 98) | pub fn self_node_id(&self) -> &NodeIdRef {
    method gossip_listen_addr (line 102) | pub fn gossip_listen_addr(&self) -> SocketAddr {
    method gossip_advertise_addr (line 106) | pub fn gossip_advertise_addr(&self) -> SocketAddr {
    method join (line 111) | pub async fn join(
    method ready_members (line 216) | pub async fn ready_members(&self) -> Vec<ClusterMember> {
    method ready_members_watcher (line 221) | async fn ready_members_watcher(&self) -> WatchStream<Vec<ClusterMember...
    method ready_nodes (line 225) | pub async fn ready_nodes(&self) -> Vec<ClusterNode> {
    method change_stream (line 237) | pub fn change_stream(&self) -> ClusterChangeStream {
    method is_self_node_ready (line 257) | pub async fn is_self_node_ready(&self) -> bool {
    method set_self_node_readiness (line 268) | pub async fn set_self_node_readiness(&self, readiness: bool) {
    method set_self_key_value (line 279) | pub async fn set_self_key_value(&self, key: impl Display, value: impl ...
    method set_self_key_value_delete_after_ttl (line 289) | pub async fn set_self_key_value_delete_after_ttl(
    method get_self_key_value (line 301) | pub async fn get_self_key_value(&self, key: &str) -> Option<String> {
    method remove_self_key (line 311) | pub async fn remove_self_key(&self, key: &str) {
    method subscribe (line 320) | pub async fn subscribe(
    method wait_for_ready_members (line 333) | pub async fn wait_for_ready_members<F>(
    method snapshot (line 354) | pub async fn snapshot(&self) -> ClusterSnapshot {
    method leave (line 385) | pub async fn leave(&self) {
    method initiate_shutdown (line 395) | pub async fn initiate_shutdown(&self) -> anyhow::Result<()> {
    method update_self_node_pipeline_metrics (line 403) | pub async fn update_self_node_pipeline_metrics(
    method update_self_node_indexing_tasks (line 431) | pub async fn update_self_node_indexing_tasks(&self, indexing_tasks: &[...
    method chitchat (line 438) | pub async fn chitchat(&self) -> Arc<Mutex<Chitchat>> {
    method chitchat_server_termination_watcher (line 442) | pub async fn chitchat_server_termination_watcher(
  method fmt (line 74) | fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
  method create (line 454) | fn create(&self) -> ClusterChangeStream {
  function spawn_ready_members_task (line 460) | fn spawn_ready_members_task(
  function parse_indexing_tasks (line 496) | pub fn parse_indexing_tasks(node_state: &NodeState) -> Vec<IndexingTask> {
  function set_indexing_tasks_in_node_state (line 514) | pub(crate) fn set_indexing_tasks_in_node_state(
  function indexing_task_to_chitchat_kv (line 532) | fn indexing_task_to_chitchat_kv(indexing_task: &IndexingTask) -> (String...
  function parse_shard_ids_str (line 548) | fn parse_shard_ids_str(shard_ids_str: &str) -> Vec<ShardId> {
  function chitchat_kv_to_indexing_task (line 556) | fn chitchat_kv_to_indexing_task(key: &str, value: &str) -> Option<Indexi...
  function spawn_change_stream_task (line 576) | async fn spawn_change_stream_task(cluster: Cluster) {
  type InnerCluster (line 621) | struct InnerCluster {
  type NodeIdSchema (line 632) | pub struct NodeIdSchema {
  type ClusterSnapshot (line 647) | pub struct ClusterSnapshot {
  function grpc_addr_from_listen_addr_for_test (line 684) | pub fn grpc_addr_from_listen_addr_for_test(listen_addr: SocketAddr) -> S...
  function create_cluster_for_test_with_id (line 690) | pub async fn create_cluster_for_test_with_id(
  function create_failure_detector_config_for_test (line 732) | fn create_failure_detector_config_for_test() -> FailureDetectorConfig {
  function create_cluster_for_test (line 742) | pub async fn create_cluster_for_test(
  function test_single_node_cluster_readiness (line 790) | async fn test_single_node_cluster_readiness() {
  function test_cluster_multiple_nodes (line 859) | async fn test_cluster_multiple_nodes() -> anyhow::Result<()> {
  function test_multi_node_cluster_readiness (line 919) | async fn test_multi_node_cluster_readiness() {
  function test_cluster_members_built_from_chitchat_state (line 960) | async fn test_cluster_members_built_from_chitchat_state() {
  function test_chitchat_state_set_high_number_of_tasks (line 1028) | async fn test_chitchat_state_set_high_number_of_tasks() {
  function test_indexing_tasks_in_given_node (line 1135) | async fn test_indexing_tasks_in_given_node(
  function test_chitchat_state_with_malformatted_indexing_task_key (line 1164) | async fn test_chitchat_state_with_malformatted_indexing_task_key() {
  function test_cluster_id_isolation (line 1189) | async fn test_cluster_id_isolation() -> anyhow::Result<()> {
  function test_serialize_indexing_tasks_aux (line 1276) | fn test_serialize_indexing_tasks_aux(
  function test_serialize_indexing_tasks (line 1286) | fn test_serialize_indexing_tasks() {
  function test_parse_shard_ids_str (line 1373) | fn test_parse_shard_ids_str() {
  function test_parse_chitchat_kv (line 1387) | fn test_parse_chitchat_kv() {

FILE: quickwit/quickwit-cluster/src/grpc_gossip.rs
  constant MAX_GOSSIP_PEERS (line 36) | const MAX_GOSSIP_PEERS: usize = 3;
  function spawn_catchup_callback_task (line 39) | pub(crate) async fn spawn_catchup_callback_task(
  function perform_grpc_gossip_rounds (line 74) | async fn perform_grpc_gossip_rounds<ClusterServiceClientFactory, Fut>(
  function wait_for_gossip_candidates (line 161) | async fn wait_for_gossip_candidates(
  function select_gossip_candidates (line 185) | fn select_gossip_candidates(
  function find_gossip_candidate_grpc_addr (line 203) | fn find_gossip_candidate_grpc_addr(
  function test_find_gossip_candidate_grpc_addr (line 228) | async fn test_find_gossip_candidate_grpc_addr() {
  function test_perform_grpc_gossip_rounds (line 262) | async fn test_perform_grpc_gossip_rounds() {

FILE: quickwit/quickwit-cluster/src/grpc_service.rs
  constant MAX_MESSAGE_SIZE (line 31) | const MAX_MESSAGE_SIZE: ByteSize = ByteSize::mib(64);
  function cluster_grpc_client (line 38) | pub(crate) async fn cluster_grpc_client(
  function cluster_grpc_server (line 49) | pub fn cluster_grpc_server(
  method fetch_cluster_state (line 60) | async fn fetch_cluster_state(
  function test_fetch_cluster_state (line 131) | async fn test_fetch_cluster_state() {

FILE: quickwit/quickwit-cluster/src/lib.rs
  type GenerationId (line 55) | pub struct GenerationId(u64);
    method as_u64 (line 58) | pub fn as_u64(&self) -> u64 {
    method now (line 62) | pub fn now() -> Self {
    method from (line 68) | fn from(generation_id: u64) -> Self {
  type CountingUdpTransport (line 73) | struct CountingUdpTransport;
  type CountingUdpSocket (line 75) | struct CountingUdpSocket {
  method send (line 85) | async fn send(&mut self, to: SocketAddr, msg: ChitchatMessage) -> anyhow...
  method recv (line 93) | async fn recv(&mut self) -> anyhow::Result<(SocketAddr, ChitchatMessage)> {
  method open (line 104) | async fn open(&self, listen_addr: SocketAddr) -> anyhow::Result<Box<dyn ...
  function start_cluster_service (line 124) | pub async fn start_cluster_service(node_config: &NodeConfig) -> anyhow::...
  function make_client_grpc_config (line 177) | pub fn make_client_grpc_config(grpc_config: &GrpcConfig) -> anyhow::Resu...
  function make_client_tls_config (line 189) | fn make_client_tls_config(tls_config: &TlsConfig) -> anyhow::Result<Clie...

FILE: quickwit/quickwit-cluster/src/member.rs
  constant GRPC_ADVERTISE_ADDR_KEY (line 32) | pub(crate) const GRPC_ADVERTISE_ADDR_KEY: &str = "grpc_advertise_addr";
  constant ENABLED_SERVICES_KEY (line 33) | pub(crate) const ENABLED_SERVICES_KEY: &str = "enabled_services";
  constant PIPELINE_METRICS_PREFIX (line 34) | pub(crate) const PIPELINE_METRICS_PREFIX: &str = "pipeline_metrics:";
  constant READINESS_KEY (line 37) | pub(crate) const READINESS_KEY: &str = "readiness";
  constant READINESS_VALUE_READY (line 38) | pub(crate) const READINESS_VALUE_READY: &str = "READY";
  constant READINESS_VALUE_NOT_READY (line 39) | pub(crate) const READINESS_VALUE_NOT_READY: &str = "NOT_READY";
  constant AVAILABILITY_ZONE_KEY (line 41) | pub(crate) const AVAILABILITY_ZONE_KEY: &str = "availability_zone";
  constant INDEXING_CPU_CAPACITY_KEY (line 43) | pub const INDEXING_CPU_CAPACITY_KEY: &str = "indexing_cpu_capacity";
  type NodeStateExt (line 45) | pub(crate) trait NodeStateExt {
    method grpc_advertise_addr (line 46) | fn grpc_advertise_addr(&self) -> anyhow::Result<SocketAddr>;
    method is_ready (line 48) | fn is_ready(&self) -> bool;
    method size_bytes (line 50) | fn size_bytes(&self) -> usize;
    method ingester_status (line 52) | fn ingester_status(&self) -> IngesterStatus;
    method availability_zone (line 54) | fn availability_zone(&self) -> Option<String>;
    method grpc_advertise_addr (line 58) | fn grpc_advertise_addr(&self) -> anyhow::Result<SocketAddr> {
    method is_ready (line 70) | fn is_ready(&self) -> bool {
    method size_bytes (line 77) | fn size_bytes(&self) -> usize {
    method ingester_status (line 86) | fn ingester_status(&self) -> IngesterStatus {
    method availability_zone (line 92) | fn availability_zone(&self) -> Option<String> {
  type ClusterMember (line 99) | pub struct ClusterMember {
    method chitchat_id (line 131) | pub fn chitchat_id(&self) -> ChitchatId {
  method from (line 141) | fn from(member: ClusterMember) -> Self {
  function parse_indexing_cpu_capacity (line 146) | fn parse_indexing_cpu_capacity(node_state: &NodeState) -> CpuCapacity {
  function build_cluster_member (line 159) | pub(crate) fn build_cluster_member(
  function parse_enabled_services_str (line 197) | fn parse_enabled_services_str(

FILE: quickwit/quickwit-cluster/src/metrics.rs
  type ClusterMetrics (line 27) | pub struct ClusterMetrics {
  method default (line 43) | fn default() -> Self {
  function spawn_metrics_task (line 123) | pub(crate) fn spawn_metrics_task(

FILE: quickwit/quickwit-cluster/src/node.rs
  type ClusterNode (line 30) | pub struct ClusterNode {
    method try_new (line 36) | pub(crate) fn try_new(
    method for_test (line 62) | pub async fn for_test(
    method chitchat_id (line 88) | pub fn chitchat_id(&self) -> &ChitchatId {
    method node_id (line 92) | pub fn node_id(&self) -> &NodeIdRef {
    method channel (line 96) | pub fn channel(&self) -> Channel {
    method enabled_services (line 100) | pub fn enabled_services(&self) -> &HashSet<QuickwitService> {
    method is_indexer (line 104) | pub fn is_indexer(&self) -> bool {
    method is_ingester (line 110) | pub fn is_ingester(&self) -> bool {
    method is_searcher (line 116) | pub fn is_searcher(&self) -> bool {
    method grpc_advertise_addr (line 122) | pub fn grpc_advertise_addr(&self) -> SocketAddr {
    method indexing_tasks (line 126) | pub fn indexing_tasks(&self) -> &[IndexingTask] {
    method indexing_capacity (line 130) | pub fn indexing_capacity(&self) -> CpuCapacity {
    method ingester_status (line 134) | pub fn ingester_status(&self) -> IngesterStatus {
    method is_ready (line 138) | pub fn is_ready(&self) -> bool {
    method is_self_node (line 142) | pub fn is_self_node(&self) -> bool {
    method availability_zone (line 146) | pub fn availability_zone(&self) -> Option<&str> {
  method fmt (line 152) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method eq (line 163) | fn eq(&self, other: &Self) -> bool {
  type InnerNode (line 174) | struct InnerNode {

FILE: quickwit/quickwit-codegen/example/build.rs
  function main (line 17) | fn main() {

FILE: quickwit/quickwit-codegen/example/src/codegen/hello.rs
  type HelloRequest (line 4) | pub struct HelloRequest {
  type HelloResponse (line 10) | pub struct HelloResponse {
  type GoodbyeRequest (line 16) | pub struct GoodbyeRequest {
  type GoodbyeResponse (line 22) | pub struct GoodbyeResponse {
  type PingRequest (line 28) | pub struct PingRequest {
  type PingResponse (line 34) | pub struct PingResponse {
  method rpc_name (line 44) | fn rpc_name() -> &'static str {
  method rpc_name (line 49) | fn rpc_name() -> &'static str {
  method rpc_name (line 54) | fn rpc_name() -> &'static str {
  type HelloStream (line 58) | pub type HelloStream<T> = quickwit_common::ServiceStream<crate::HelloRes...
  type Hello (line 61) | pub trait Hello: std::fmt::Debug + Send + Sync + 'static {
    method hello (line 63) | async fn hello(&self, request: HelloRequest) -> crate::HelloResult<Hel...
    method goodbye (line 65) | async fn goodbye(
    method ping (line 70) | async fn ping(
    method check_connectivity (line 74) | async fn check_connectivity(&self) -> anyhow::Result<()>;
    method endpoints (line 75) | fn endpoints(&self) -> Vec<quickwit_common::uri::Uri>;
    method hello (line 171) | async fn hello(&self, request: HelloRequest) -> crate::HelloResult<Hel...
    method goodbye (line 174) | async fn goodbye(
    method ping (line 180) | async fn ping(
    method check_connectivity (line 186) | async fn check_connectivity(&self) -> anyhow::Result<()> {
    method endpoints (line 189) | fn endpoints(&self) -> Vec<quickwit_common::uri::Uri> {
    method hello (line 202) | async fn hello(
    method goodbye (line 208) | async fn goodbye(
    method ping (line 214) | async fn ping(
    method check_connectivity (line 220) | async fn check_connectivity(&self) -> anyhow::Result<()> {
    method endpoints (line 223) | fn endpoints(&self) -> Vec<quickwit_common::uri::Uri> {
    method hello (line 305) | async fn hello(&self, request: HelloRequest) -> crate::HelloResult<Hel...
    method goodbye (line 308) | async fn goodbye(
    method ping (line 314) | async fn ping(
    method check_connectivity (line 320) | async fn check_connectivity(&self) -> anyhow::Result<()> {
    method endpoints (line 323) | fn endpoints(&self) -> Vec<quickwit_common::uri::Uri> {
    method hello (line 685) | async fn hello(&self, request: HelloRequest) -> crate::HelloResult<Hel...
    method goodbye (line 688) | async fn goodbye(
    method ping (line 694) | async fn ping(
    method check_connectivity (line 700) | async fn check_connectivity(&self) -> anyhow::Result<()> {
    method endpoints (line 706) | fn endpoints(&self) -> Vec<quickwit_common::uri::Uri> {
    method hello (line 744) | async fn hello(&self, request: HelloRequest) -> crate::HelloResult<Hel...
    method goodbye (line 755) | async fn goodbye(
    method ping (line 769) | async fn ping(
    method check_connectivity (line 791) | async fn check_connectivity(&self) -> anyhow::Result<()> {
    method endpoints (line 797) | fn endpoints(&self) -> Vec<quickwit_common::uri::Uri> {
  type HelloClient (line 78) | pub struct HelloClient {
    method new (line 84) | pub fn new<T>(instance: T) -> Self
    method as_grpc_service (line 97) | pub fn as_grpc_service(
    method from_channel (line 110) | pub fn from_channel(
    method from_balance_channel (line 130) | pub fn from_balance_channel(
    method from_mailbox (line 147) | pub fn from_mailbox<A>(mailbox: quickwit_actors::Mailbox<A>) -> Self
    method tower (line 154) | pub fn tower() -> HelloTowerLayerStack {
    method from_mock (line 158) | pub fn from_mock(mock: MockHello) -> Self {
    method mocked (line 165) | pub fn mocked() -> Self {
  type InnerHelloClient (line 82) | struct InnerHelloClient(std::sync::Arc<dyn Hello>);
    type Response (line 232) | type Response = HelloResponse;
    type Error (line 233) | type Error = crate::HelloError;
    type Future (line 234) | type Future = BoxFuture<Self::Response, Self::Error>;
    method poll_ready (line 235) | fn poll_ready(
    method call (line 241) | fn call(&mut self, request: HelloRequest) -> Self::Future {
    type Response (line 248) | type Response = GoodbyeResponse;
    type Error (line 249) | type Error = crate::HelloError;
    type Future (line 250) | type Future = BoxFuture<Self::Response, Self::Error>;
    method poll_ready (line 251) | fn poll_ready(
    method call (line 257) | fn call(&mut self, request: GoodbyeRequest) -> Self::Future {
    type Response (line 264) | type Response = HelloStream<PingResponse>;
    type Error (line 265) | type Error = crate::HelloError;
    type Future (line 266) | type Future = BoxFuture<Self::Response, Self::Error>;
    method poll_ready (line 267) | fn poll_ready(
    method call (line 273) | fn call(
  type MockHelloWrapper (line 197) | pub struct MockHelloWrapper {
  type BoxFuture (line 228) | pub type BoxFuture<T, E> = std::pin::Pin<
  type HelloTowerServiceStack (line 284) | struct HelloTowerServiceStack {
  type HelloLayer (line 327) | type HelloLayer = quickwit_common::tower::BoxLayer<
  type GoodbyeLayer (line 333) | type GoodbyeLayer = quickwit_common::tower::BoxLayer<
  type PingLayer (line 343) | type PingLayer = quickwit_common::tower::BoxLayer<
  type HelloTowerLayerStack (line 354) | pub struct HelloTowerLayerStack {
    method stack_layer (line 360) | pub fn stack_layer<L>(mut self, layer: L) -> Self
    method stack_hello_layer (line 445) | pub fn stack_hello_layer<L>(mut self, layer: L) -> Self
    method stack_goodbye_layer (line 464) | pub fn stack_goodbye_layer<L>(mut self, layer: L) -> Self
    method stack_ping_layer (line 483) | pub fn stack_ping_layer<L>(mut self, layer: L) -> Self
    method build (line 504) | pub fn build<T>(self, instance: T) -> HelloClient
    method build_from_channel (line 511) | pub fn build_from_channel(
    method build_from_balance_channel (line 527) | pub fn build_from_balance_channel(
    method build_from_mailbox (line 541) | pub fn build_from_mailbox<A>(
    method build_from_mock (line 555) | pub fn build_from_mock(self, mock: MockHello) -> HelloClient {
    method build_from_inner_client (line 560) | fn build_from_inner_client(self, inner_client: InnerHelloClient) -> He...
  type MailboxAdapter (line 595) | struct MailboxAdapter<A: quickwit_actors::Actor, E> {
  type Target (line 603) | type Target = quickwit_actors::Mailbox<A>;
  function deref (line 604) | fn deref(&self) -> &Self::Target {
  type HelloMailbox (line 609) | pub struct HelloMailbox<A: quickwit_actors::Actor> {
  function new (line 613) | pub fn new(instance: quickwit_actors::Mailbox<A>) -> Self {
  method clone (line 622) | fn clone(&self) -> Self {
  type Response (line 640) | type Response = T;
  type Error (line 641) | type Error = crate::HelloError;
  type Future (line 642) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 643) | fn poll_ready(
  function call (line 652) | fn call(&mut self, message: M) -> Self::Future {
  type HelloGrpcClientAdapter (line 714) | pub struct HelloGrpcClientAdapter<T> {
  function new (line 722) | pub fn new(
  type HelloGrpcServerAdapter (line 808) | pub struct HelloGrpcServerAdapter {
    method new (line 812) | pub fn new<T>(instance: T) -> Self
    method hello (line 823) | async fn hello(
    method goodbye (line 834) | async fn goodbye(
    type PingStream (line 845) | type PingStream = quickwit_common::ServiceStream<tonic::Result<PingRes...
    method ping (line 846) | async fn ping(
  type HelloGrpcClient (line 875) | pub struct HelloGrpcClient<T> {
  function connect (line 880) | pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
  function new (line 896) | pub fn new(inner: T) -> Self {
  function with_origin (line 900) | pub fn with_origin(inner: T, origin: Uri) -> Self {
  function with_interceptor (line 904) | pub fn with_interceptor<F>(
  function send_compressed (line 928) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function accept_compressed (line 934) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 942) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 950) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  function hello (line 955) | pub async fn hello(
  function goodbye (line 974) | pub async fn goodbye(
  function ping (line 996) | pub async fn ping(
  type HelloGrpc (line 1031) | pub trait HelloGrpc: std::marker::Send + std::marker::Sync + 'static {
    method hello (line 1033) | async fn hello(
    method goodbye (line 1038) | async fn goodbye(
    method ping (line 1049) | async fn ping(
  type HelloGrpcServer (line 1055) | pub struct HelloGrpcServer<T> {
  function new (line 1063) | pub fn new(inner: T) -> Self {
  function from_arc (line 1066) | pub fn from_arc(inner: Arc<T>) -> Self {
  function with_interceptor (line 1075) | pub fn with_interceptor<F>(
  function accept_compressed (line 1086) | pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function send_compressed (line 1092) | pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
  function max_decoding_message_size (line 1100) | pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
  function max_encoding_message_size (line 1108) | pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
  type Response (line 1119) | type Response = http::Response<tonic::body::Body>;
  type Error (line 1120) | type Error = std::convert::Infallible;
  type Future (line 1121) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 1122) | fn poll_ready(
  function call (line 1128) | fn call(&mut self, req: http::Request<B>) -> Self::Future {
  method clone (line 1285) | fn clone(&self) -> Self {
  constant SERVICE_NAME (line 1297) | pub const SERVICE_NAME: &str = "hello.Hello";
  constant NAME (line 1299) | const NAME: &'static str = SERVICE_NAME;

FILE: quickwit/quickwit-codegen/example/src/error.rs
  type HelloError (line 26) | pub enum HelloError {
    method from (line 72) | fn from(error: AskError<E>) -> Self {
    method from (line 78) | fn from(_: TimeoutExceeded) -> Self {
  method error_code (line 40) | fn error_code(&self) -> ServiceErrorCode {
  method new_internal (line 52) | fn new_internal(message: String) -> Self {
  method new_timeout (line 56) | fn new_timeout(message: String) -> Self {
  method new_too_many_requests (line 60) | fn new_too_many_requests() -> Self {
  method new_unavailable (line 64) | fn new_unavailable(message: String) -> Self {

FILE: quickwit/quickwit-codegen/example/src/lib.rs
  type HelloResult (line 34) | pub type HelloResult<T> = Result<T, HelloError>;
  type Counter (line 37) | struct Counter<S> {
  type Response (line 45) | type Response = S::Response;
  type Error (line 46) | type Error = S::Error;
  type Future (line 47) | type Future = S::Future;
  function poll_ready (line 49) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 53) | fn call(&mut self, req: R) -> Self::Future {
  type CounterLayer (line 61) | struct CounterLayer {
    type Service (line 66) | type Service = Counter<S>;
    method layer (line 68) | fn layer(&self, inner: S) -> Self::Service {
  function spawn_ping_response_stream (line 77) | fn spawn_ping_response_stream(
  type HelloImpl (line 115) | struct HelloImpl {
  method hello (line 121) | async fn hello(&self, request: HelloRequest) -> HelloResult<HelloRespons...
  method goodbye (line 132) | async fn goodbye(&self, request: GoodbyeRequest) -> HelloResult<GoodbyeR...
  method ping (line 140) | async fn ping(
  method check_connectivity (line 147) | async fn check_connectivity(&self) -> anyhow::Result<()> {
  method endpoints (line 151) | fn endpoints(&self) -> Vec<Uri> {
  constant MAX_GRPC_MESSAGE_SIZE (line 178) | const MAX_GRPC_MESSAGE_SIZE: ByteSize = ByteSize::mib(1);
  function test_hello_codegen (line 181) | async fn test_hello_codegen() {
  function test_hello_codegen_grpc (line 267) | async fn test_hello_codegen_grpc() {
  function test_hello_codegen_grpc_with_compression (line 357) | async fn test_hello_codegen_grpc_with_compression() {
  function test_hello_codegen_actor (line 497) | async fn test_hello_codegen_actor() {
  function test_hello_codegen_tower_stack_layers (line 637) | async fn test_hello_codegen_tower_stack_layers() {
  function test_hello_codegen_tower_stack_layer_ordering (line 684) | async fn test_hello_codegen_tower_stack_layer_ordering() {
  function test_from_channel (line 786) | async fn test_from_channel() {
  function test_balance_channel (line 795) | async fn test_balance_channel() {
  function test_hello_codegen_mock (line 834) | async fn test_hello_codegen_mock() {
  function test_transport_errors_handling (line 871) | async fn test_transport_errors_handling() {
  function test_balanced_channel_timeout_with_server_crash (line 916) | async fn test_balanced_channel_timeout_with_server_crash() {

FILE: quickwit/quickwit-codegen/src/codegen.rs
  type Codegen (line 24) | pub struct Codegen;
    method run (line 27) | pub fn run(mut args: CodegenBuilder) -> anyhow::Result<()> {
    method builder (line 55) | pub fn builder() -> CodegenBuilder {
  type CodegenBuilder (line 61) | pub struct CodegenBuilder {
    method with_protos (line 73) | pub fn with_protos(mut self, protos: &[&str]) -> Self {
    method with_includes (line 78) | pub fn with_includes(mut self, includes: &[&str]) -> Self {
    method with_output_dir (line 83) | pub fn with_output_dir(mut self, path: &str) -> Self {
    method with_result_type_path (line 88) | pub fn with_result_type_path(mut self, path: &str) -> Self {
    method with_error_type_path (line 93) | pub fn with_error_type_path(mut self, path: &str) -> Self {
    method with_prost_config (line 98) | pub fn with_prost_config(mut self, prost_config: ProstConfig) -> Self {
    method generate_extra_service_methods (line 103) | pub fn generate_extra_service_methods(mut self) -> Self {
    method generate_rpc_name_impls (line 109) | pub fn generate_rpc_name_impls(mut self) -> Self {
    method run (line 114) | pub fn run(self) -> anyhow::Result<()> {
  type QuickwitServiceGenerator (line 124) | struct QuickwitServiceGenerator {
    method new (line 133) | fn new(
  method generate (line 154) | fn generate(&mut self, service: Service, buf: &mut String) {
  method finalize (line 169) | fn finalize(&mut self, buf: &mut String) {
  type CodegenContext (line 174) | struct CodegenContext {
    method from_service (line 200) | fn from_service(
  function generate_all (line 271) | fn generate_all(
  type SynMethod (line 329) | struct SynMethod {
    method request_type (line 340) | fn request_type(&self, mock: bool) -> TokenStream {
    method rpc_name (line 354) | fn rpc_name(&self, mock: bool) -> TokenStream {
    method response_type (line 364) | fn response_type(&self, context: &CodegenContext, mock: bool) -> Token...
    method parse_prost_methods (line 379) | fn parse_prost_methods(methods: &[Method]) -> Vec<Self> {
  function generate_prom_labels_impl_for_requests (line 404) | fn generate_prom_labels_impl_for_requests(context: &CodegenContext) -> T...
  function generate_comment_attributes (line 429) | fn generate_comment_attributes(comments: &Comments) -> Vec<syn::Attribut...
  function generate_service_trait (line 442) | fn generate_service_trait(context: &CodegenContext) -> TokenStream {
  function generate_service_trait_methods (line 464) | fn generate_service_trait_methods(context: &CodegenContext) -> TokenStre...
  function generate_extra_methods_calling_inner (line 483) | fn generate_extra_methods_calling_inner() -> TokenStream {
  function generate_client (line 495) | fn generate_client(context: &CodegenContext) -> TokenStream {
  function generate_client_methods (line 660) | fn generate_client_methods(context: &CodegenContext, mock: bool) -> Toke...
  function generate_tower_services (line 689) | fn generate_tower_services(context: &CodegenContext) -> TokenStream {
  function generate_tower_svc_stack (line 725) | fn generate_tower_svc_stack(context: &CodegenContext) -> TokenStream {
  function generate_tower_svc_stack_attributes (line 746) | fn generate_tower_svc_stack_attributes(context: &CodegenContext) -> Toke...
  function generate_tower_svc_stack_service_impl (line 764) | fn generate_tower_svc_stack_service_impl(context: &CodegenContext) -> To...
  function generate_tower_layer_stack (line 798) | fn generate_tower_layer_stack(context: &CodegenContext) -> TokenStream {
  function generate_layer_stack_types_and_attributes (line 816) | fn generate_layer_stack_types_and_attributes(
  function generate_layer_stack_impl (line 843) | fn generate_layer_stack_impl(context: &CodegenContext) -> TokenStream {
  function generate_tower_mailbox (line 980) | fn generate_tower_mailbox(context: &CodegenContext) -> TokenStream {
  function generate_mailbox_bounds_and_methods (line 1088) | fn generate_mailbox_bounds_and_methods(
  function generate_grpc_client_adapter (line 1117) | fn generate_grpc_client_adapter(context: &CodegenContext) -> TokenStream {
  function generate_grpc_client_adapter_methods (line 1178) | fn generate_grpc_client_adapter_methods(context: &CodegenContext) -> Tok...
  function generate_grpc_server_adapter (line 1215) | fn generate_grpc_server_adapter(context: &CodegenContext) -> TokenStream {
  function generate_grpc_server_adapter_methods (line 1245) | fn generate_grpc_server_adapter_methods(context: &CodegenContext) -> Tok...
  type WithSuffixServiceGenerator (line 1305) | struct WithSuffixServiceGenerator {
    method new (line 1311) | fn new(suffix: &str, service_generator: Box<dyn ServiceGenerator>) -> ...
  method generate (line 1320) | fn generate(&mut self, mut service: Service, buf: &mut String) {
  method finalize (line 1325) | fn finalize(&mut self, buf: &mut String) {
  method finalize_package (line 1329) | fn finalize_package(&mut self, package: &str, buf: &mut String) {

FILE: quickwit/quickwit-common/build.rs
  function main (line 15) | fn main() {

FILE: quickwit/quickwit-common/src/alloc_tracker.rs
  type Allocation (line 21) | struct Allocation {
  type AllocStat (line 27) | pub struct AllocStat {
  type TrackerStatus (line 34) | enum TrackerStatus {
  type Allocations (line 43) | pub struct Allocations {
    method init (line 85) | pub fn init(&mut self, reporting_interval_bytes: u64) {
    method record_allocation (line 101) | pub fn record_allocation(
    method record_reallocation (line 149) | pub fn record_reallocation(
    method record_deallocation (line 201) | pub fn record_deallocation(&mut self, ptr: *mut u8) {
  method default (line 52) | fn default() -> Self {
  type AllocRecordingResponse (line 68) | pub enum AllocRecordingResponse {
  type ReallocRecordingResponse (line 75) | pub enum ReallocRecordingResponse {
  function as_ptr (line 230) | fn as_ptr(i: usize) -> *mut u8 {
  function test_record_allocation_and_deallocation (line 235) | fn test_record_allocation_and_deallocation() {
  function test_record_allocation_and_reallocation (line 277) | fn test_record_allocation_and_reallocation() {
  function test_tracker_full (line 362) | fn test_tracker_full() {

FILE: quickwit/quickwit-common/src/binary_heap.rs
  type IntoIterSorted (line 23) | pub struct IntoIterSorted<T> {
  function new (line 28) | pub fn new(instance: BinaryHeap<T>) -> Self {
  type Item (line 34) | type Item = T;
  method next (line 37) | fn next(&mut self) -> Option<T> {
  method size_hint (line 42) | fn size_hint(&self) -> (usize, Option<usize>) {
  function top_k (line 54) | pub fn top_k<T, SortKeyFn, O>(
  type OrderItemPair (line 93) | struct OrderItemPair<O: Ord, T> {
  method cmp (line 99) | fn cmp(&self, other: &Self) -> Ordering {
  method partial_cmp (line 105) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method eq (line 111) | fn eq(&self, other: &Self) -> bool {
  type SortKeyMapper (line 118) | pub trait SortKeyMapper<Value> {
    method get_sort_key (line 120) | fn get_sort_key(&self, value: &Value) -> Self::Key;
  type TopK (line 125) | pub struct TopK<T, O: Ord, S> {
  function new (line 137) | pub fn new(k: usize, sort_key_mapper: S) -> Self {
  function at_capacity (line 146) | pub fn at_capacity(&self) -> bool {
  function max_len (line 150) | pub fn max_len(&self) -> usize {
  function add_entries (line 155) | pub fn add_entries(&mut self, mut items: impl Iterator<Item = T>) {
  function add_entry (line 177) | pub fn add_entry(&mut self, item: T) {
  function peek_worst (line 182) | pub fn peek_worst(&self) -> Option<&T> {
  function finalize (line 187) | pub fn finalize(self) -> Vec<T> {
  function test_top_k (line 202) | fn test_top_k() {
  function test_incremental_top_k (line 216) | fn test_incremental_top_k() {

FILE: quickwit/quickwit-common/src/coolid.rs
  constant ADJECTIVES (line 18) | const ADJECTIVES: &[&str] = &[
  function new_coolid (line 86) | pub fn new_coolid(name: &str) -> String {
  function test_coolid (line 104) | fn test_coolid() {

FILE: quickwit/quickwit-common/src/cpus.rs
  constant QW_NUM_CPUS_ENV_KEY (line 20) | const QW_NUM_CPUS_ENV_KEY: &str = "QW_NUM_CPUS";
  constant KUBERNETES_LIMITS_CPU (line 21) | const KUBERNETES_LIMITS_CPU: &str = "KUBERNETES_LIMITS_CPU";
  function num_cpus (line 29) | pub fn num_cpus() -> usize {
  function num_cpus_aux (line 34) | fn num_cpus_aux() -> usize {
  function parse_cpu_to_mcpu (line 65) | fn parse_cpu_to_mcpu(cpu_string: &str) -> Result<usize, &'static str> {
  function get_num_cpus_from_env (line 90) | fn get_num_cpus_from_env(env_key: &str) -> Option<usize> {
  function test_millicores (line 109) | fn test_millicores() {
  function test_cores (line 116) | fn test_cores() {
  function test_fractional_cores (line 122) | fn test_fractional_cores() {
  function test_with_whitespace (line 129) | fn test_with_whitespace() {
  function test_invalid_input (line 135) | fn test_invalid_input() {

FILE: quickwit/quickwit-common/src/fs.rs
  function empty_dir (line 22) | pub async fn empty_dir<P: AsRef<Path>>(path: P) -> anyhow::Result<()> {
  function get_cache_directory_path (line 35) | pub fn get_cache_directory_path(data_dir_path: &Path) -> PathBuf {
  function get_disk_size (line 41) | pub fn get_disk_size(dir_path: &Path) -> Option<ByteSize> {
  function test_empty_dir (line 78) | async fn test_empty_dir() -> anyhow::Result<()> {

FILE: quickwit/quickwit-common/src/io.rs
  constant MAX_NUM_BYTES_WRITTEN_AT_ONCE (line 44) | const MAX_NUM_BYTES_WRITTEN_AT_ONCE: usize = 1 << 20;
  function truncate_bytes (line 46) | fn truncate_bytes(bytes: &[u8]) -> &[u8] {
  type IoMetrics (line 51) | struct IoMetrics {
  method default (line 56) | fn default() -> Self {
  constant REFILL_DURATION (line 78) | const REFILL_DURATION: Duration = if cfg!(test) {
  function limiter (line 85) | pub fn limiter(throughput: ByteSize) -> Limiter {
  type IoControls (line 92) | pub struct IoControls {
    method progress (line 114) | pub fn progress(&self) -> &Progress {
    method kill (line 118) | pub fn kill(&self) {
    method num_bytes (line 122) | pub fn num_bytes(&self) -> u64 {
    method check_if_alive (line 126) | pub fn check_if_alive(&self) -> io::Result<ProtectedZoneGuard> {
    method set_component (line 134) | pub fn set_component(mut self, component: &str) -> Self {
    method set_throughput_limit (line 139) | pub fn set_throughput_limit(self, throughput: ByteSize) -> Self {
    method set_throughput_limiter_opt (line 146) | pub fn set_throughput_limiter_opt(mut self, throughput_limiter_opt: Op...
    method set_bytes_counter (line 151) | pub fn set_bytes_counter(mut self, bytes_counter: IntCounter) -> Self {
    method set_progress (line 156) | pub fn set_progress(mut self, progress: Progress) -> Self {
    method set_kill_switch (line 161) | pub fn set_kill_switch(mut self, kill_switch: KillSwitch) -> Self {
    method consume_blocking (line 165) | fn consume_blocking(&self, num_bytes: usize) -> io::Result<()> {
  method default (line 100) | fn default() -> Self {
  type ControlledWrite (line 176) | pub struct ControlledWrite<A: IoControlsAccess, W> {
  function poll_limited (line 193) | pub(crate) fn poll_limited(
  function quirky_truncate_slices (line 240) | fn quirky_truncate_slices<'a, 'b>(bufs: &'b [IoSlice<'a>], max_len: usiz...
  method poll_write (line 255) | fn poll_write(
  method poll_write_vectored (line 265) | fn poll_write_vectored(
  method poll_flush (line 278) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Re...
  method poll_shutdown (line 282) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  type IoControlsAccess (line 287) | pub trait IoControlsAccess: Sized {
    method wrap_write (line 288) | fn wrap_write<W>(self, wrt: W) -> ControlledWrite<Self, W> {
    method apply (line 296) | fn apply<F, R>(&self, f: F) -> R
    method apply (line 301) | fn apply<F, R>(&self, f: F) -> R
  function underlying_wrt (line 310) | pub fn underlying_wrt(&mut self) -> &mut W {
  function check_if_alive (line 314) | fn check_if_alive(&self) -> io::Result<ProtectedZoneGuard> {
  function write (line 323) | fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
  function flush (line 331) | fn flush(&mut self) -> io::Result<()> {
  function test_controlled_writer_limited_async (line 352) | async fn test_controlled_writer_limited_async() {
  function test_controlled_writer_no_limit_async (line 369) | async fn test_controlled_writer_no_limit_async() {
  function test_controlled_writer_limited_sync (line 385) | fn test_controlled_writer_limited_sync() {
  function test_controlled_writer_no_limit_sync (line 402) | fn test_controlled_writer_no_limit_sync() {
  function test_truncate_io_slices_one_slice_too_long_corner_case (line 418) | fn test_truncate_io_slices_one_slice_too_long_corner_case() {
  function test_truncate_io_empty (line 424) | fn test_truncate_io_empty() {
  function test_truncate_io_slices (line 429) | fn test_truncate_io_slices() {

FILE: quickwit/quickwit-common/src/jemalloc_profiled.rs
  constant DEFAULT_MIN_ALLOC_BYTES_FOR_PROFILING (line 29) | const DEFAULT_MIN_ALLOC_BYTES_FOR_PROFILING: u64 = 64 * 1024;
  constant DEFAULT_REPORTING_INTERVAL_BYTES (line 30) | const DEFAULT_REPORTING_INTERVAL_BYTES: u64 = 1024 * 1024 * 1024;
  constant JEMALLOC_PROFILER_TARGET (line 34) | pub const JEMALLOC_PROFILER_TARGET: &str = "jemprof";
  type Flags (line 42) | struct Flags {
  function start_profiling (line 78) | pub fn start_profiling(
  function stop_profiling (line 123) | pub fn stop_profiling() {
  type JemallocProfiled (line 142) | pub struct JemallocProfiled(pub Jemalloc);
  method alloc (line 146) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
  method alloc_zeroed (line 155) | unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
  method dealloc (line 164) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
  method realloc (line 172) | unsafe fn realloc(&self, old_ptr: *mut u8, layout: Layout, new_size: usi...
  function identify_callsite (line 184) | fn identify_callsite(callsite_hash: u64, stat: AllocStat) {
  function backtrace_hash (line 193) | fn backtrace_hash() -> u64 {
  function track_alloc_call (line 204) | fn track_alloc_call(ptr: *mut u8, layout: Layout) {
  function track_dealloc_call (line 231) | fn track_dealloc_call(ptr: *mut u8, layout: Layout) {
  function track_realloc_call (line 239) | fn track_realloc_call(old_ptr: *mut u8, new_ptr: *mut u8, current_layout...
  function test_size_of_flags (line 266) | fn test_size_of_flags() {

FILE: quickwit/quickwit-common/src/kill_switch.rs
  type KillSwitch (line 21) | pub struct KillSwitch {
    method is_alive (line 51) | pub fn is_alive(&self) -> bool {
    method is_dead (line 55) | pub fn is_dead(&self) -> bool {
    method kill (line 59) | pub fn kill(&self) {
    method child (line 66) | pub fn child(&self) -> KillSwitch {
  type Inner (line 25) | struct Inner {
    method kill (line 82) | pub fn kill(&self) {
  method default (line 31) | fn default() -> Self {
  function garbage_collect (line 39) | fn garbage_collect(children: &mut Vec<Weak<Inner>>) {
  function test_kill_switch (line 98) | fn test_kill_switch() {
  function test_kill_switch_child (line 111) | fn test_kill_switch_child() {
  function test_kill_switch_grandchildren (line 123) | fn test_kill_switch_grandchildren() {
  function test_kill_switch_to_quoque_me_fili (line 137) | fn test_kill_switch_to_quoque_me_fili() {

FILE: quickwit/quickwit-common/src/lib.rs
  function true_fn (line 71) | pub const fn true_fn() -> bool {
  function is_true (line 77) | pub fn is_true(value: &bool) -> bool {
  function chunk_range (line 81) | pub fn chunk_range(range: Range<usize>, chunk_size: usize) -> impl Itera...
  function into_u64_range (line 88) | pub fn into_u64_range(range: Range<usize>) -> Range<u64> {
  function setup_logging_for_tests (line 92) | pub fn setup_logging_for_tests() {
  function split_file (line 96) | pub fn split_file(split_id: impl Display) -> String {
  function get_from_env_opt_aux (line 100) | fn get_from_env_opt_aux<T: Debug>(
  function get_from_env (line 118) | pub fn get_from_env<T: FromStr + Debug>(key: &str, default_value: T, sen...
  function get_from_env_opt (line 127) | pub fn get_from_env_opt<T: FromStr + Debug>(key: &str, sensitive: bool) ...
  function get_bool_from_env_opt (line 131) | pub fn get_bool_from_env_opt(key: &str) -> Option<bool> {
  function get_bool_from_env (line 135) | pub fn get_bool_from_env(key: &str, default_value: bool) -> bool {
  function truncate_str (line 144) | pub fn truncate_str(text: &str, max_len: usize) -> &str {
  function extract_time_range (line 157) | pub fn extract_time_range(
  function is_disjoint (line 179) | pub fn is_disjoint(left: &Range<i64>, right: &RangeInclusive<i64>) -> bo...
  function is_false (line 184) | pub fn is_false(value: &bool) -> bool {
  function no_color (line 188) | pub fn no_color() -> bool {
  function div_ceil_u32 (line 230) | pub const fn div_ceil_u32(lhs: u32, rhs: u32) -> u32 {
  function div_ceil (line 237) | pub const fn div_ceil(lhs: i64, rhs: i64) -> i64 {
  function spawn_named_task (line 271) | pub fn spawn_named_task<F>(future: F, _name: &'static str) -> tokio::tas...
  function spawn_named_task_on (line 281) | pub fn spawn_named_task_on<F>(
  function spawn_named_task (line 295) | pub fn spawn_named_task<F>(future: F, name: &'static str) -> tokio::task...
  function spawn_named_task_on (line 308) | pub fn spawn_named_task_on<F>(
  function parse_bool_lenient (line 323) | pub fn parse_bool_lenient(bool_str: &str) -> Option<bool> {
  function test_get_from_env (line 346) | fn test_get_from_env() {
  function test_truncate_str (line 360) | fn test_truncate_str() {
  function test_ignore_io_error_macro (line 373) | fn test_ignore_io_error_macro() {
  function test_div_ceil (line 382) | fn test_div_ceil() {
  function test_div_ceil_u32 (line 408) | fn test_div_ceil_u32() {
  function test_parse_bool_lenient (line 419) | fn test_parse_bool_lenient() {

FILE: quickwit/quickwit-common/src/metrics.rs
  type HistogramVec (line 26) | pub struct HistogramVec<const N: usize> {
  function with_label_values (line 31) | pub fn with_label_values(&self, label_values: [&str; N]) -> Histogram {
  type IntCounterVec (line 37) | pub struct IntCounterVec<const N: usize> {
  function new (line 42) | pub fn new(
  function with_label_values (line 62) | pub fn with_label_values(&self, label_values: [&str; N]) -> IntCounter {
  type IntGaugeVec (line 68) | pub struct IntGaugeVec<const N: usize> {
  function with_label_values (line 73) | pub fn with_label_values(&self, label_values: [&str; N]) -> IntGauge {
  function register_info (line 78) | pub fn register_info(name: &'static str, help: &'static str, kvs: BTreeM...
  function new_counter (line 88) | pub fn new_counter(
  function new_counter_vec (line 107) | pub fn new_counter_vec<const N: usize>(
  function new_float_gauge (line 120) | pub fn new_float_gauge(
  function new_gauge (line 139) | pub fn new_gauge(
  function new_gauge_vec (line 158) | pub fn new_gauge_vec<const N: usize>(
  function new_histogram (line 182) | pub fn new_histogram(name: &str, help: &str, subsystem: &str, buckets: V...
  function new_histogram_vec (line 192) | pub fn new_histogram_vec<const N: usize>(
  type GaugeGuard (line 218) | pub struct GaugeGuard<'a> {
  function fmt (line 224) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  function from_gauge (line 230) | pub fn from_gauge(gauge: &'a IntGauge) -> Self {
  function get (line 234) | pub fn get(&self) -> i64 {
  function add (line 238) | pub fn add(&mut self, delta: i64) {
  function sub (line 243) | pub fn sub(&mut self, delta: i64) {
  method drop (line 250) | fn drop(&mut self) {
  type OwnedGaugeGuard (line 255) | pub struct OwnedGaugeGuard {
    method fmt (line 261) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
    method from_gauge (line 267) | pub fn from_gauge(gauge: IntGauge) -> Self {
    method get (line 271) | pub fn get(&self) -> i64 {
    method add (line 275) | pub fn add(&mut self, delta: i64) {
    method sub (line 280) | pub fn sub(&mut self, delta: i64) {
  method drop (line 287) | fn drop(&mut self) {
  function metrics_text_payload (line 292) | pub fn metrics_text_payload() -> Result<String, String> {
  type MemoryMetrics (line 305) | pub struct MemoryMetrics {
  method default (line 313) | fn default() -> Self {
  type InFlightDataGauges (line 342) | pub struct InFlightDataGauges {
    method file (line 383) | pub fn file(&self) -> &IntGauge {
    method ingest (line 389) | pub fn ingest(&self) -> &IntGauge {
    method kafka (line 398) | pub fn kafka(&self) -> &IntGauge {
    method kinesis (line 404) | pub fn kinesis(&self) -> &IntGauge {
    method pubsub (line 413) | pub fn pubsub(&self) -> &IntGauge {
    method pulsar (line 422) | pub fn pulsar(&self) -> &IntGauge {
    method other (line 431) | pub fn other(&self) -> &IntGauge {
  method default (line 357) | fn default() -> Self {
  function index_label (line 442) | pub fn index_label(index_id: &str) -> &str {

FILE: quickwit/quickwit-common/src/net.rs
  type Host (line 31) | pub enum Host {
    method is_unspecified (line 38) | pub fn is_unspecified(&self) -> bool {
    method with_port (line 46) | pub fn with_port(&self, port: u16) -> HostAddr {
    method resolve (line 54) | pub async fn resolve(&self) -> anyhow::Result<IpAddr> {
    method deserialize (line 90) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    method from (line 98) | fn from(ip_addr: IpAddr) -> Self {
    method from (line 104) | fn from(ip_addr: Ipv4Addr) -> Self {
    method from (line 110) | fn from(ip_addr: Ipv6Addr) -> Self {
  method default (line 65) | fn default() -> Self {
  method fmt (line 71) | fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
  method serialize (line 80) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type Err (line 116) | type Err = anyhow::Error;
  method from_str (line 118) | fn from_str(host: &str) -> Result<Self, Self::Err> {
  type HostAddr (line 131) | pub struct HostAddr {
    method parse_with_default_port (line 147) | pub fn parse_with_default_port(host_addr: &str, default_port: u16) -> ...
    method resolve (line 181) | pub async fn resolve(&self) -> anyhow::Result<SocketAddr> {
    method to_socket_addr (line 189) | pub fn to_socket_addr(self) -> Option<SocketAddr> {
  method fmt (line 199) | fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
  function find_available_tcp_port (line 210) | pub fn find_available_tcp_port() -> anyhow::Result<u16> {
  function find_private_ip (line 218) | pub fn find_private_ip() -> Option<(String, IpAddr)> {
  function _find_private_ip (line 223) | fn _find_private_ip(interfaces: &[NetworkInterface]) -> Option<(String, ...
  function is_dormant (line 255) | fn is_dormant(interface: &NetworkInterface) -> bool {
  function is_dormant (line 260) | fn is_dormant(_interface: &NetworkInterface) -> bool {
  function get_socket_addr (line 265) | pub async fn get_socket_addr<T: ToSocketAddrs + std::fmt::Debug>(
  function is_forwardable_ip (line 277) | fn is_forwardable_ip(ip_addr: &IpAddr) -> bool {
  function is_private_ip (line 307) | fn is_private_ip(ip_addr: &IpAddr) -> bool {
  function get_hostname (line 320) | pub fn get_hostname() -> io::Result<String> {
  function _get_hostname (line 325) | fn _get_hostname(hostname: OsString) -> io::Result<String> {
  function get_short_hostname (line 336) | pub fn get_short_hostname() -> io::Result<String> {
  function is_valid_hostname (line 355) | pub fn is_valid_hostname(hostname: &str) -> bool {
  function test_parse_host (line 383) | fn test_parse_host() {
  function test_deserialize_host (line 399) | fn test_deserialize_host() {
  function test_serialize_host (line 415) | fn test_serialize_host() {
  function test_parse_addr_helper (line 430) | fn test_parse_addr_helper(addr: &str, expected_addr_opt: Option<&str>) {
  function test_parse_addr_with_ips (line 449) | async fn test_parse_addr_with_ips() {
  function test_is_valid_hostname (line 474) | fn test_is_valid_hostname() {
  function test_find_private_ip (line 510) | fn test_find_private_ip() {
  function test_is_forwardable_ip (line 558) | fn test_is_forwardable_ip() {
  function test_is_private_ip (line 574) | fn test_is_private_ip() {
  function test_get_hostname (line 590) | fn test_get_hostname() {

FILE: quickwit/quickwit-common/src/path_hasher.rs
  constant SEPARATOR (line 23) | const SEPARATOR: &[u8] = &[255];
  type PathHasher (line 32) | pub struct PathHasher {
    method hash_path (line 47) | pub fn hash_path(segments: &[&[u8]]) -> u64 {
    method append (line 60) | pub fn append(&mut self, payload: &[u8]) {
    method finish_leaf (line 66) | pub fn finish_leaf(&self) -> u64 {
    method finish_intermediate (line 71) | pub fn finish_intermediate(&self) -> u64 {
  method clone (line 38) | fn clone(&self) -> PathHasher {

FILE: quickwit/quickwit-common/src/pretty.rs
  type PrettySample (line 18) | pub struct PrettySample<I>(I, usize);
  function new (line 21) | pub fn new(slice: I, sample_size: usize) -> Self {
  function fmt (line 31) | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
  type PrettyDisplay (line 55) | pub trait PrettyDisplay {
    method pretty_display (line 56) | fn pretty_display(&self) -> impl fmt::Display;
    method pretty_display (line 79) | fn pretty_display(&self) -> impl fmt::Display {
    method pretty_display (line 109) | fn pretty_display(&self) -> impl fmt::Display {
  type DurationPrettyDisplay (line 59) | struct DurationPrettyDisplay<'a>(&'a Duration);
  function fmt (line 62) | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  type SequencePrettyDisplay (line 84) | struct SequencePrettyDisplay<I>(I);
  function fmt (line 91) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function test_pretty_sample (line 119) | fn test_pretty_sample() {
  function test_duration_pretty_display (line 137) | fn test_duration_pretty_display() {
  function test_sequence_pretty_display (line 152) | fn test_sequence_pretty_display() {

FILE: quickwit/quickwit-common/src/progress.rs
  type Progress (line 25) | pub struct Progress(Arc<AtomicU32>);
    method record_progress (line 78) | pub fn record_progress(&self) {
    method protect_future (line 84) | pub async fn protect_future<Fut, T>(&self, future: Fut) -> T
    method protect_zone (line 90) | pub fn protect_zone(&self) -> ProtectedZoneGuard {
    method registered_activity_since_last_call (line 117) | pub fn registered_activity_since_last_call(&self) -> bool {
  type ProgressState (line 28) | enum ProgressState {
    method into (line 52) | fn into(self) -> u32 {
    method from (line 62) | fn from(level: u32) -> Self {
  method default (line 72) | fn default() -> Progress {
  type ProtectedZoneGuard (line 132) | pub struct ProtectedZoneGuard(Arc<AtomicU32>);
  method drop (line 135) | fn drop(&mut self) {
  function test_progress (line 146) | fn test_progress() {
  function test_progress_protect_zone (line 155) | fn test_progress_protect_zone() {
  function test_progress_several_protect_zone (line 170) | fn test_progress_several_protect_zone() {

FILE: quickwit/quickwit-common/src/pubsub.rs
  constant EVENT_SUBSCRIPTION_CALLBACK_TIMEOUT (line 27) | const EVENT_SUBSCRIPTION_CALLBACK_TIMEOUT: Duration = Duration::from_sec...
  type Event (line 29) | pub trait Event: fmt::Debug + Clone + Send + Sync + 'static {}
  type EventSubscriber (line 32) | pub trait EventSubscriber<E>: Send + Sync + 'static {
    method handle_event (line 33) | async fn handle_event(&mut self, event: E);
  method handle_event (line 42) | async fn handle_event(&mut self, event: E) {
  type EventSubscriptions (line 47) | type EventSubscriptions<E> = HashMap<usize, EventSubscription<E>>;
  type EventBroker (line 59) | pub struct EventBroker {
    method subscribe_aux (line 72) | fn subscribe_aux<E, S>(&self, subscriber: S, with_timeout: bool) -> Ev...
    method subscribe (line 127) | pub fn subscribe<E>(&self, subscriber: impl EventSubscriber<E>) -> Eve...
    method subscribe_without_timeout (line 136) | pub fn subscribe_without_timeout<E>(
    method publish (line 147) | pub fn publish<E>(&self, event: E)
  type InnerEventBroker (line 64) | struct InnerEventBroker {
  type EventSubscription (line 162) | struct EventSubscription<E> {
  function trigger (line 172) | fn trigger(&self, event: E) {
  function trigger_just_log_on_timeout (line 184) | fn trigger_just_log_on_timeout(&self, event: E) {
  function trigger_abort_on_timeout (line 208) | fn trigger_abort_on_timeout(&self, event: E) {
  type EventSubscriptionHandle (line 230) | pub struct EventSubscriptionHandle {
    method cancel (line 237) | pub fn cancel(self) {}
    method forever (line 241) | pub fn forever(mut self) {
  method drop (line 247) | fn drop(&mut self) {
  type MyEvent (line 263) | struct MyEvent {
  type MySubscriber (line 270) | struct MySubscriber {
    method handle_event (line 276) | async fn handle_event(&mut self, event: MyEvent) {
  function test_event_broker (line 282) | async fn test_event_broker() {
  function test_event_broker_handle_drop (line 306) | async fn test_event_broker_handle_drop() {
  function test_event_broker_handle_cancel (line 317) | async fn test_event_broker_handle_cancel() {
  function test_event_broker_handle_forever (line 330) | async fn test_event_broker_handle_forever() {

FILE: quickwit/quickwit-common/src/rand.rs
  function append_random_suffix (line 19) | pub fn append_random_suffix(string: &str) -> String {
  function test_append_random_suffix (line 36) | fn test_append_random_suffix() -> anyhow::Result<()> {

FILE: quickwit/quickwit-common/src/rate_limited_tracing.rs
  type LogSiteMetadata (line 30) | struct LogSiteMetadata {
    method from (line 36) | fn from(val: u64) -> LogSiteMetadata {
  function from (line 45) | fn from(count: LogSiteMetadata) -> u64 {
  function should_log (line 52) | pub fn should_log<F: Fn() -> Instant>(
  function _check_macro_works (line 176) | fn _check_macro_works() {
  function test_rate_limited_log_single_thread (line 202) | fn test_rate_limited_log_single_thread() {

FILE: quickwit/quickwit-common/src/rate_limiter.rs
  type RateLimiterSettings (line 25) | pub struct RateLimiterSettings {
  method default (line 41) | fn default() -> Self {
  type RateLimiter (line 59) | pub struct RateLimiter<C: Clock = DefaultClock> {
  method default (line 73) | fn default() -> Self {
  function from_settings (line 80) | pub fn from_settings(settings: RateLimiterSettings) -> Self {
  function from_settings_with_clock (line 87) | pub fn from_settings_with_clock(settings: RateLimiterSettings, clock: C)...
  function available_permits (line 105) | pub fn available_permits(&mut self) -> u64 {
  function acquire (line 111) | pub fn acquire(&mut self, num_permits: u64) -> bool {
  function acquire_bytes (line 118) | pub fn acquire_bytes(&mut self, bytes: ByteSize) -> bool {
  function drain (line 124) | pub fn drain(&mut self) {
  function release (line 130) | pub fn release(&mut self, num_permits: u64) {
  function acquire_inner (line 134) | fn acquire_inner(&mut self, num_permits: u64) -> bool {
  function refill (line 143) | fn refill(&mut self, now: C::Instant) {
  function test_rate_limiter_acquire (line 163) | fn test_rate_limiter_acquire() {
  function test_rate_limiter_drain (line 193) | fn test_rate_limiter_drain() {
  function test_rate_limiter_release (line 214) | fn test_rate_limiter_release() {
  function test_rate_limiter_refill (line 232) | fn test_rate_limiter_refill() {
  function test_rate_limiter_available_permits (line 261) | fn test_rate_limiter_available_permits() {

FILE: quickwit/quickwit-common/src/rendezvous_hasher.rs
  function node_affinity (line 23) | pub fn node_affinity<T: Hash, U: Hash>(node: T, key: &U) -> u64 {
  function sort_by_rendez_vous_hash (line 32) | pub fn sort_by_rendez_vous_hash<T: Hash, U: Hash>(nodes: &mut [T], key: ...
  function test_socket_addr (line 43) | fn test_socket_addr(last_byte: u8) -> SocketAddr {
  function test_utils_sort_by_rendez_vous_hash (line 48) | fn test_utils_sort_by_rendez_vous_hash() {

FILE: quickwit/quickwit-common/src/retry.rs
  type Retryable (line 23) | pub trait Retryable {
    method is_retryable (line 24) | fn is_retryable(&self) -> bool {
    method is_retryable (line 45) | fn is_retryable(&self) -> bool {
    method is_retryable (line 204) | fn is_retryable(&self) -> bool {
  type Retry (line 30) | pub enum Retry<E> {
  function into_inner (line 36) | pub fn into_inner(self) -> E {
  type RetryParams (line 54) | pub struct RetryParams {
    method standard (line 63) | pub fn standard() -> Self {
    method aggressive (line 74) | pub fn aggressive() -> Self {
    method no_retries (line 83) | pub fn no_retries() -> Self {
    method compute_delay (line 101) | pub fn compute_delay(&self, num_attempts: usize) -> Duration {
    method for_test (line 114) | pub fn for_test() -> Self {
  type MockableSleep (line 124) | pub trait MockableSleep {
    method sleep (line 125) | async fn sleep(&self, duration: Duration);
    method sleep (line 132) | async fn sleep(&self, duration: Duration) {
    method sleep (line 216) | async fn sleep(&self, _duration: Duration) {
  type TokioSleep (line 128) | pub struct TokioSleep;
  function retry_with_mockable_sleep (line 137) | pub async fn retry_with_mockable_sleep<U, E, Fut>(
  function retry (line 180) | pub async fn retry<U, E, Fut>(retry_params: &RetryParams, f: impl Fn() -...
  type Retry (line 198) | pub enum Retry<E> {
  type NoopSleep (line 212) | struct NoopSleep;
  function simulate_retries (line 221) | async fn simulate_retries<T>(values: Vec<Result<T, Retry<usize>>>) -> Re...
  function test_retry_accepts_ok (line 237) | async fn test_retry_accepts_ok() {
  function test_retry_does_retry (line 242) | async fn test_retry_does_retry() {
  function test_retry_stops_retrying_on_non_retryable_error (line 250) | async fn test_retry_stops_retrying_on_non_retryable_error() {
  function test_retry_retries_up_at_most_attempts_times (line 258) | async fn test_retry_retries_up_at_most_attempts_times() {
  function test_retry_retries_up_to_max_attempts_times (line 270) | async fn test_retry_retries_up_to_max_attempts_times() {
  function test_retry_delay_does_not_overflow_aux (line 278) | fn test_retry_delay_does_not_overflow_aux(retry_params: RetryParams) {

FILE: quickwit/quickwit-common/src/ring_buffer.rs
  type RingBuffer (line 31) | pub struct RingBuffer<T: Copy + Default, const N: usize> {
  method default (line 38) | fn default() -> Self {
  method fmt (line 48) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function push_back (line 54) | pub fn push_back(&mut self, value: T) {
  function last (line 62) | pub fn last(&self) -> Option<T> {
  function front (line 69) | pub fn front(&self) -> Option<T> {
  function len (line 76) | pub fn len(&self) -> usize {
  function is_empty (line 80) | pub fn is_empty(&self) -> bool {
  function iter (line 84) | pub fn iter(&self) -> impl Iterator<Item = &T> + '_ {
  function test_empty (line 95) | fn test_empty() {
  function test_single_push (line 105) | fn test_single_push() {
  function test_partial_fill (line 116) | fn test_partial_fill() {
  function test_exactly_full (line 128) | fn test_exactly_full() {
  function test_wrap_around (line 140) | fn test_wrap_around() {
  function test_many_wraps (line 152) | fn test_many_wraps() {
  function test_debug (line 164) | fn test_debug() {

FILE: quickwit/quickwit-common/src/runtimes.rs
  type RuntimeType (line 30) | pub enum RuntimeType {
    method get_runtime_handle (line 143) | pub fn get_runtime_handle(self) -> tokio::runtime::Handle {
  type RuntimesConfig (line 49) | pub struct RuntimesConfig {
    method light_for_tests (line 58) | pub fn light_for_tests() -> RuntimesConfig {
    method with_num_cpus (line 65) | pub fn with_num_cpus(num_cpus: usize) -> Self {
  method default (line 91) | fn default() -> Self {
  function start_runtimes (line 97) | fn start_runtimes(config: RuntimesConfig) -> HashMap<RuntimeType, Runtim...
  function initialize_runtimes (line 137) | pub fn initialize_runtimes(runtimes_config: RuntimesConfig) -> anyhow::R...
  function scrape_tokio_runtime_metrics (line 164) | pub fn scrape_tokio_runtime_metrics(handle: &tokio::runtime::Handle, lab...
  type PrometheusRuntimeMetrics (line 177) | struct PrometheusRuntimeMetrics {
    method new (line 185) | pub fn new(label: &'static str) -> Self {
    method update (line 215) | pub fn update(&mut self, runtime_metrics: &RuntimeMetrics) {
  function test_runtimes_config_default (line 231) | fn test_runtimes_config_default() {
  function test_runtimes_with_given_num_cpus_10 (line 238) | fn test_runtimes_with_given_num_cpus_10() {
  function test_runtimes_with_given_num_cpus_3 (line 245) | fn test_runtimes_with_given_num_cpus_3() {

FILE: quickwit/quickwit-common/src/shared_consts.rs
  constant FIELD_PRESENCE_FIELD_NAME (line 22) | pub const FIELD_PRESENCE_FIELD_NAME: &str = "_field_presence";
  constant MINIMUM_DELETION_GRACE_PERIOD (line 24) | pub const MINIMUM_DELETION_GRACE_PERIOD: Duration = Duration::from_secs(...
  constant MAXIMUM_DELETION_GRACE_PERIOD (line 25) | const MAXIMUM_DELETION_GRACE_PERIOD: Duration = Duration::from_secs(2 * ...
  function split_deletion_grace_period (line 35) | pub fn split_deletion_grace_period() -> Duration {
  constant SCROLL_BATCH_LEN (line 62) | pub const SCROLL_BATCH_LEN: usize = 1_000;
  constant INGESTER_PRIMARY_SHARDS_PREFIX (line 65) | pub const INGESTER_PRIMARY_SHARDS_PREFIX: &str = "ingester.primary_shard...
  constant INGESTER_STATUS_KEY (line 68) | pub const INGESTER_STATUS_KEY: &str = "ingester.status";
  constant INGESTER_CAPACITY_SCORE_PREFIX (line 71) | pub const INGESTER_CAPACITY_SCORE_PREFIX: &str = "ingester.capacity_scor...
  constant SPLIT_FIELDS_FILE_NAME (line 74) | pub const SPLIT_FIELDS_FILE_NAME: &str = "split_fields";
  constant DEFAULT_SHARD_THROUGHPUT_LIMIT (line 78) | pub const DEFAULT_SHARD_THROUGHPUT_LIMIT: ByteSize = ByteSize::mib(5);
  constant DEFAULT_SHARD_BURST_LIMIT (line 80) | pub const DEFAULT_SHARD_BURST_LIMIT: ByteSize = ByteSize::mib(50);
  constant DEFAULT_SHARD_SCALE_UP_FACTOR (line 83) | pub const DEFAULT_SHARD_SCALE_UP_FACTOR: f32 = 1.5;

FILE: quickwit/quickwit-common/src/socket_addr_legacy_hash.rs
  type SocketAddrLegacyHash (line 34) | pub struct SocketAddrLegacyHash<'a>(pub &'a SocketAddr);
  function hash (line 37) | fn hash<H: Hasher>(&self, state: &mut H) {
  function sample_socket_addr_v4 (line 60) | fn sample_socket_addr_v4() -> SocketAddr {
  function sample_socket_addr_v6 (line 64) | fn sample_socket_addr_v6() -> SocketAddr {
  function compute_hash (line 71) | fn compute_hash(hashable: impl std::hash::Hash) -> u64 {
  function test_legacy_hash_socket_addr_v4 (line 83) | fn test_legacy_hash_socket_addr_v4() {
  function test_legacy_hash_socket_addr_v6 (line 90) | fn test_legacy_hash_socket_addr_v6() {

FILE: quickwit/quickwit-common/src/sorted_iter.rs
  type Sorted (line 21) | trait Sorted {}
  type SortedIterator (line 24) | pub trait SortedIterator: Iterator + Sized {
    method diff (line 26) | fn diff<U>(self, other: U) -> DiffIterator<Self, U>
  type Diff (line 36) | pub enum Diff<K> {
  type DiffIterator (line 42) | pub struct DiffIterator<T: Iterator, U: Iterator> {
  type Item (line 53) | type Item = Diff<K>;
  method next (line 55) | fn next(&mut self) -> Option<Self::Item> {
  type SortedByKeyIterator (line 110) | pub trait SortedByKeyIterator<K, V>: Iterator + Sized {
    method diff_by_key (line 112) | fn diff_by_key<U, W>(self, other: U) -> DiffByKeyIterator<Self, U>
  type KeyDiff (line 122) | pub enum KeyDiff<K, V, W> {
  type DiffByKeyIterator (line 128) | pub struct DiffByKeyIterator<T: Iterator, U: Iterator> {
  type Item (line 139) | type Item = KeyDiff<K, V, W>;
  method next (line 141) | fn next(&mut self) -> Option<Self::Item> {
  function test_diff (line 201) | fn test_diff() {
  function test_diff_by_key (line 246) | fn test_diff_by_key() {

FILE: quickwit/quickwit-common/src/stream_utils.rs
  type BoxStream (line 29) | pub type BoxStream<T> = Pin<Box<dyn Stream<Item = T> + Send + Unpin + 's...
  type ServiceStream (line 32) | pub struct ServiceStream<T> {
  function new (line 39) | pub fn new(inner: BoxStream<T>) -> Self {
  function empty (line 43) | pub fn empty() -> Self {
  function map (line 49) | pub fn map<F, U>(self, f: F) -> ServiceStream<U>
  function fmt (line 63) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new_bounded (line 73) | pub fn new_bounded(capacity: usize) -> (mpsc::Sender<T>, Self) {
  function new_bounded_with_gauge (line 78) | pub fn new_bounded_with_gauge(
  function new_unbounded (line 92) | pub fn new_unbounded() -> (mpsc::UnboundedSender<T>, Self) {
  function new_unbounded_with_gauge (line 97) | pub fn new_unbounded_with_gauge(gauge: &'static IntGauge) -> (TrackedUnb...
  function new_watch (line 112) | pub fn new_watch(init: T) -> (watch::Sender<T>, Self) {
  function map_err (line 123) | pub fn map_err<F, U>(self, f: F) -> ServiceStream<Result<T, U>>
  type Item (line 135) | type Item = T;
  method poll_next (line 137) | fn poll_next(
  function from (line 148) | fn from(receiver: mpsc::Receiver<T>) -> Self {
  function from (line 158) | fn from(receiver: mpsc::UnboundedReceiver<T>) -> Self {
  function from (line 168) | fn from(receiver: watch::Receiver<T>) -> Self {
  function from (line 181) | fn from(streaming: tonic::Streaming<T>) -> Self {
  function from (line 193) | fn from(streaming: tonic::Streaming<T>) -> Self {
  function from (line 216) | fn from(values: Vec<T>) -> Self {
  method rpc_name (line 226) | fn rpc_name() -> &'static str {
  type InFlightValue (line 231) | pub struct InFlightValue<T>(T, #[allow(dead_code)] GaugeGuard<'static>);
  function fmt (line 236) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function new (line 242) | pub fn new(value: T, value_size: ByteSize, gauge: &'static IntGauge) -> ...
  function into_inner (line 249) | pub fn into_inner(self) -> T {
  type TrackedSender (line 254) | pub struct TrackedSender<T> {
  function send (line 260) | pub async fn send(
  type TrackedUnboundedSender (line 272) | pub struct TrackedUnboundedSender<T> {
  function send (line 278) | pub fn send(&self, value: T, value_size: ByteSize) -> Result<(), mpsc::e...
  function test_service_stream_map (line 293) | async fn test_service_stream_map() {
  function test_tracked_service_stream_bounded (line 302) | async fn test_tracked_service_stream_bounded() {
  function test_tracked_service_stream_unbounded (line 321) | async fn test_tracked_service_stream_unbounded() {

FILE: quickwit/quickwit-common/src/temp_dir.rs
  constant MAX_LENGTH (line 24) | const MAX_LENGTH: usize = 255;
  constant SEPARATOR (line 26) | const SEPARATOR: char = '%';
  constant NUM_RAND_CHARS (line 28) | const NUM_RAND_CHARS: usize = 6;
  function create_or_purge_directory (line 31) | pub async fn create_or_purge_directory(path: &Path) -> io::Result<PathBu...
  type TempDirectory (line 40) | pub struct TempDirectory {
    method path (line 47) | pub fn path(&self) -> &Path {
    method named_temp_child (line 54) | pub fn named_temp_child(&self, prefix: &str) -> io::Result<TempDirecto...
    method for_test (line 66) | pub fn for_test() -> Self {
  type Builder (line 73) | pub struct Builder<'a> {
  method default (line 81) | fn default() -> Self {
  function rand_bytes (line 93) | pub fn rand_bytes(&mut self, rand: usize) -> &mut Self {
  function max_length (line 99) | pub fn max_length(&mut self, max_length: usize) -> &mut Self {
  function join (line 105) | pub fn join(&mut self, name: &'a str) -> &mut Self {
  function push_str (line 112) | fn push_str(buffer: &mut String, addition: &'a str, size: usize) -> usize {
  function prefix (line 133) | fn prefix(&self) -> io::Result<String> {
  function tempdir (line 189) | pub fn tempdir(&self) -> io::Result<TempDirectory> {
  function tempdir_in (line 202) | pub fn tempdir_in<P: AsRef<Path>>(&self, dir: P) -> io::Result<TempDirec...
  function test_push_str (line 224) | fn test_push_str() {
  function assert_truncate (line 240) | fn assert_truncate(addition: &str, size: usize, expected_addition: &str,...
  function test_random_failures (line 248) | fn test_random_failures() {
  function test_prefix (line 276) | fn test_prefix() {
  function assert_prefix (line 314) | fn assert_prefix(parts: Vec<&str>, size: usize, expected_path: &str) {
  function assert_prefix_err (line 325) | fn assert_prefix_err(expected_err: &str, parts: Vec<&str>, size: usize) {
  function test_prefix_random (line 337) | fn test_prefix_random() {
  function test_directory_creation_and_removal (line 384) | fn test_directory_creation_and_removal() {
  function test_directory_creation_and_removal_with_random_bytes (line 400) | fn test_directory_creation_and_removal_with_random_bytes() {
  function test_directory_randomness (line 417) | fn test_directory_randomness() {

FILE: quickwit/quickwit-common/src/test_utils.rs
  function wait_until_predicate (line 23) | pub async fn wait_until_predicate<Fut>(
  function wait_for_server_ready (line 46) | pub async fn wait_for_server_ready(socket_addr: SocketAddr) -> anyhow::R...

FILE: quickwit/quickwit-common/src/thread_pool.rs
  type ThreadPool (line 31) | pub struct ThreadPool {
    method new (line 38) | pub fn new(name: &'static str, num_threads_opt: Option<usize>) -> Thre...
    method get_underlying_rayon_thread_pool (line 59) | pub fn get_underlying_rayon_thread_pool(&self) -> Arc<rayon::ThreadPoo...
    method run_cpu_intensive (line 78) | pub fn run_cpu_intensive<F, R>(
  function run_cpu_intensive (line 115) | pub fn run_cpu_intensive<F, R>(cpu_intensive_fn: F) -> impl Future<Outpu...
  type Panicked (line 130) | pub struct Panicked;
    method fmt (line 133) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type ThreadPoolMetrics (line 140) | struct ThreadPoolMetrics {
  method default (line 146) | fn default() -> Self {
  function test_run_cpu_intensive (line 177) | async fn test_run_cpu_intensive() {
  function test_run_cpu_intensive_panicks (line 182) | async fn test_run_cpu_intensive_panicks() {
  function test_run_cpu_intensive_panicks_do_not_shrink_thread_pool (line 187) | async fn test_run_cpu_intensive_panicks_do_not_shrink_thread_pool() {
  function test_run_cpu_intensive_abort (line 194) | async fn test_run_cpu_intensive_abort() {

FILE: quickwit/quickwit-common/src/tower/box_layer.rs
  type BoxLayer (line 23) | pub struct BoxLayer<S, R, T, E> {
  function new (line 28) | pub fn new<L>(inner_layer: L) -> Self
  type Service (line 46) | type Service = BoxService<R, T, E>;
  function layer (line 48) | fn layer(&self, inner: S) -> Self::Service {
  method clone (line 54) | fn clone(&self) -> Self {
  function fmt (line 62) | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {

FILE: quickwit/quickwit-common/src/tower/box_service.rs
  type CloneService (line 22) | trait CloneService<R, T, E>:
  type BoxService (line 41) | pub struct BoxService<R, T, E> {
  method clone (line 46) | fn clone(&self) -> Self {
  function new (line 54) | pub fn new<S>(inner: S) -> Self
  type Response (line 65) | type Response = T;
  type Error (line 66) | type Error = E;
  type Future (line 67) | type Future = BoxFuture<T, E>;
  function poll_ready (line 69) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), E>> {
  function call (line 73) | fn call(&mut self, request: R) -> BoxFuture<T, E> {
  function fmt (line 79) | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {

FILE: quickwit/quickwit-common/src/tower/buffer.rs
  type BufferError (line 28) | pub enum BufferError {
  type Buffer (line 36) | pub struct Buffer<S, R>
  function new (line 48) | pub fn new(service: S, bound: usize) -> Self
  type Response (line 69) | type Response = S::Response;
  type Error (line 70) | type Error = S::Error;
  type Future (line 71) | type Future = BoxFuture<Self::Response, Self::Error>;
  function poll_ready (line 73) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 77) | fn call(&mut self, request: R) -> Self::Future {
  function downcast_error (line 85) | fn downcast_error<E>(error: BoxError) -> E
  function fmt (line 108) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method clone (line 121) | fn clone(&self) -> Self {
  type BufferLayer (line 129) | pub struct BufferLayer<R> {
  function new (line 135) | pub fn new(bound: usize) -> Self {
  type Service (line 150) | type Service = Buffer<S, R>;
  function layer (line 152) | fn layer(&self, service: S) -> Self::Service {
  function fmt (line 158) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method clone (line 166) | fn clone(&self) -> Self {
  type MyServiceError (line 180) | enum MyServiceError {
    method from (line 190) | fn from(_: BufferError) -> Self {
  type MyService (line 196) | struct MyService {
    type Response (line 201) | type Response = usize;
    type Error (line 202) | type Error = MyServiceError;
    type Future (line 203) | type Future = BoxFuture<Self::Response, Self::Error>;
    method poll_ready (line 205) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Sel...
    method call (line 215) | fn call(&mut self, (dividend, divisor): (usize, usize)) -> Self::Future {
  function test_buffer_error (line 228) | async fn test_buffer_error() {
  function test_buffer_closed (line 258) | async fn test_buffer_closed() {

FILE: quickwit/quickwit-common/src/tower/change.rs
  type Change (line 18) | pub enum Change<K, V> {

FILE: quickwit/quickwit-common/src/tower/circuit_breaker.rs
  type CircuitBreakerLayer (line 47) | pub struct CircuitBreakerLayer<Evaluator> {
  type CircuitBreakerEvaluator (line 55) | pub trait CircuitBreakerEvaluator: Clone {
    method is_circuit_breaker_error (line 58) | fn is_circuit_breaker_error(&self, output: &Result<Self::Response, Sel...
    method make_circuit_breaker_output (line 59) | fn make_circuit_breaker_output(&self) -> Self::Error;
    method make_layer (line 60) | fn make_layer(
    type Response (line 285) | type Response = ();
    type Error (line 286) | type Error = TestError;
    method is_circuit_breaker_error (line 288) | fn is_circuit_breaker_error(&self, output: &Result<Self::Response, Sel...
    method make_circuit_breaker_output (line 292) | fn make_circuit_breaker_output(&self) -> TestError {
  type Service (line 77) | type Service = CircuitBreaker<S, Evaluator>;
  function layer (line 79) | fn layer(&self, service: S) -> CircuitBreaker<S, Evaluator> {
  type CircuitBreakerInner (line 99) | struct CircuitBreakerInner<Evaluator> {
  function get_state (line 109) | fn get_state(&mut self) -> CircuitBreakerState {
  function receive_error (line 125) | fn receive_error(&mut self) {
  function receive_success (line 161) | fn receive_success(&mut self) {
  type CircuitBreaker (line 177) | pub struct CircuitBreaker<S, Evaluator> {
  function fmt (line 183) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type CircuitBreakerState (line 189) | enum CircuitBreakerState {
  type ClosedState (line 196) | struct ClosedState {
  type Response (line 206) | type Response = S::Response;
  type Error (line 207) | type Error = S::Error;
  type Future (line 208) | type Future = CircuitBreakerFuture<S::Future, Evaluator>;
    type Output (line 244) | type Output = F::Output;
    method poll (line 246) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 210) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 224) | fn call(&mut self, request: R) -> Self::Future {
  type CircuitBreakerFuture (line 233) | pub struct CircuitBreakerFuture<F, Evaluator> {
  type TestError (line 276) | enum TestError {
  type TestCircuitBreakerEvaluator (line 282) | struct TestCircuitBreakerEvaluator;
  function test_circuit_breaker (line 298) | async fn test_circuit_breaker() {

FILE: quickwit/quickwit-common/src/tower/delay.rs
  type Delay (line 26) | pub struct Delay<S> {
  type Response (line 34) | type Response = S::Response;
  type Error (line 35) | type Error = S::Error;
  type Future (line 36) | type Future = DelayFuture<S::Future>;
    type Output (line 64) | type Output = Result<T, E>;
    method poll (line 66) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 38) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 42) | fn call(&mut self, request: R) -> Self::Future {
  type DelayFuture (line 53) | pub struct DelayFuture<F> {
  type DelayLayer (line 81) | pub struct DelayLayer {
    method new (line 87) | pub fn new(delay: Duration) -> Self {
    type Service (line 93) | type Service = Delay<S>;
    method layer (line 95) | fn layer(&self, service: S) -> Self::Service {
  function test_delay (line 113) | async fn test_delay() {

FILE: quickwit/quickwit-common/src/tower/estimate_rate.rs
  type Handle (line 25) | pub struct Handle<T: RateEstimator> {
  method drop (line 34) | fn drop(&mut self) {
  type EstimateRate (line 45) | pub struct EstimateRate<S, T> {
  function new (line 54) | pub fn new(service: S, estimator: T) -> Self {
  function handle (line 58) | fn handle(&self, work: u64) -> Handle<T> {
  type Response (line 73) | type Response = S::Response;
  type Error (line 74) | type Error = S::Error;
  type Future (line 75) | type Future = TrackCompletionFuture<S::Future, CompleteOnResponse, Handl...
  function poll_ready (line 77) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 81) | fn call(&mut self, request: R) -> Self::Future {
  type EstimateRateLayer (line 94) | pub struct EstimateRateLayer<R, T> {
  function new (line 101) | pub fn new(estimator: T) -> Self {
  type Service (line 115) | type Service = EstimateRate<S, T>;
  function layer (line 117) | fn layer(&self, service: S) -> Self::Service {
  type Request (line 133) | struct Request;
  method cost (line 136) | fn cost(&self) -> u64 {
  type DummyEstimator (line 142) | struct DummyEstimator {
  method work (line 148) | fn work(&self) -> u64 {
  method period (line 152) | fn period(&self) -> Duration {
  method update (line 158) | fn update(&mut self, started_at: Instant, ended_at: Instant, work: u64) {
  function test_estimate_rate (line 168) | async fn test_estimate_rate() {

FILE: quickwit/quickwit-common/src/tower/event_listener.rs
  type EventListener (line 25) | pub struct EventListener<S> {
  function new (line 31) | pub fn new(inner: S, event_broker: EventBroker) -> Self {
  type Response (line 44) | type Response = S::Response;
  type Error (line 45) | type Error = S::Error;
  type Future (line 46) | type Future = ResponseFuture<S::Future, R>;
    type Output (line 95) | type Output = Result<T, E>;
    method poll (line 97) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 48) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 52) | fn call(&mut self, request: R) -> Self::Future {
  type EventListenerLayer (line 63) | pub struct EventListenerLayer {
    method new (line 68) | pub fn new(event_broker: EventBroker) -> Self {
    type Service (line 74) | type Service = EventListener<S>;
    method layer (line 76) | fn layer(&self, service: S) -> Self::Service {
  type ResponseFuture (line 83) | pub struct ResponseFuture<F, R> {
  type MyEvent (line 121) | struct MyEvent {
  type MySubscriber (line 127) | struct MySubscriber {
    method handle_event (line 133) | async fn handle_event(&mut self, _event: MyEvent) {
  function test_event_listener (line 139) | async fn test_event_listener() {

FILE: quickwit/quickwit-common/src/tower/load_shed.rs
  type LoadShed (line 27) | pub struct LoadShed<S> {
  method clone (line 36) | fn clone(&self) -> Self {
  type MakeLoadShedError (line 45) | pub trait MakeLoadShedError {
    method make_load_shed_error (line 46) | fn make_load_shed_error() -> Self;
  type Response (line 54) | type Response = S::Response;
  type Error (line 55) | type Error = S::Error;
  type Future (line 56) | type Future = LoadShedFuture<S::Future>;
    type Output (line 93) | type Output = Result<T, E>;
    method poll (line 95) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 58) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 69) | fn call(&mut self, request: R) -> Self::Future {
  type LoadShedFuture (line 84) | pub struct LoadShedFuture<F> {
  type LoadShedLayer (line 103) | pub struct LoadShedLayer {
    method new (line 110) | pub fn new(max_in_flight_requests: usize) -> Self {
    type Service (line 118) | type Service = LoadShed<S>;
    method layer (line 120) | fn layer(&self, service: S) -> Self::Service {
  function test_load_shed (line 136) | async fn test_load_shed() {

FILE: quickwit/quickwit-common/src/tower/metrics.rs
  type RpcName (line 28) | pub trait RpcName {
    method rpc_name (line 29) | fn rpc_name() -> &'static str;
    method rpc_name (line 170) | fn rpc_name() -> &'static str {
    method rpc_name (line 178) | fn rpc_name() -> &'static str {
  type GrpcMetrics (line 33) | pub struct GrpcMetrics<S> {
  type Response (line 45) | type Response = S::Response;
  type Error (line 46) | type Error = S::Error;
  type Future (line 47) | type Future = ResponseFuture<S::Future>;
    type Output (line 153) | type Output = Result<T, E>;
    method poll (line 155) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 49) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 53) | fn call(&mut self, request: R) -> Self::Future {
  type GrpcMetricsLayer (line 73) | pub struct GrpcMetricsLayer {
    method new (line 80) | pub fn new(subsystem: &'static str, kind: &'static str) -> Self {
    type Service (line 109) | type Service = GrpcMetrics<S>;
    method layer (line 111) | fn layer(&self, inner: S) -> Self::Service {
  type ResponseFuture (line 123) | pub struct ResponseFuture<F> {
  method drop (line 136) | fn drop(self: Pin<&mut Self>) {
  type HelloRequest (line 167) | struct HelloRequest;
  type GoodbyeRequest (line 175) | struct GoodbyeRequest;
  function test_grpc_metrics (line 184) | async fn test_grpc_metrics() {

FILE: quickwit/quickwit-common/src/tower/mod.rs
  type BoxError (line 59) | pub type BoxError = Box<dyn error::Error + Send + Sync + 'static>;
  type BoxFuture (line 61) | pub type BoxFuture<T, E> = Pin<Box<dyn Future<Output = Result<T, E>> + S...
  type BoxFutureInfaillible (line 63) | pub type BoxFutureInfaillible<T> = Pin<Box<dyn Future<Output = T> + Send...
  type Cost (line 65) | pub trait Cost {
    method cost (line 66) | fn cost(&self) -> u64;

FILE: quickwit/quickwit-common/src/tower/one_task_per_call_layer.rs
  type OneTaskPerCallLayer (line 41) | pub struct OneTaskPerCallLayer;
    type Service (line 44) | type Service = OneTaskPerCallService<S>;
    method layer (line 46) | fn layer(&self, service: S) -> Self::Service {
  type OneTaskPerCallService (line 52) | pub struct OneTaskPerCallService<S> {
  type Response (line 64) | type Response = S::Response;
  type Error (line 65) | type Error = S::Error;
  type Future (line 66) | type Future = UnwrapOrElseFuture<S::Response, S::Error>;
    type Output (line 93) | type Output = Result<T, E>;
    method poll (line 95) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 68) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 72) | fn call(&mut self, request: Request) -> Self::Future {
  type UnwrapOrElseFuture (line 84) | pub struct UnwrapOrElseFuture<T, E> {
  type TaskCancelled (line 118) | pub struct TaskCancelled {
    method fmt (line 124) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Request (line 149) | struct Request;
  method rpc_name (line 152) | fn rpc_name() -> &'static str {
  type DummyError (line 158) | struct DummyError;
    method from (line 161) | fn from(_task_cancelled: TaskCancelled) -> DummyError {
  type State (line 172) | struct State {
  function test_task_cancelled (line 178) | async fn test_task_cancelled() {

FILE: quickwit/quickwit-common/src/tower/pool.rs
  type Pool (line 29) | pub struct Pool<K, V> {
  function fmt (line 38) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method clone (line 44) | fn clone(&self) -> Self {
  method default (line 54) | fn default() -> Self {
  function listen_for_changes (line 67) | pub fn listen_for_changes(
  function is_empty (line 90) | pub fn is_empty(&self) -> bool {
  function len (line 98) | pub fn len(&self) -> usize {
  function keys (line 103) | pub fn keys(&self) -> Vec<K> {
  function keys_values (line 113) | pub fn keys_values(&self) -> Vec<(K, V)> {
  function values (line 123) | pub fn values(&self) -> Vec<V> {
  function pairs (line 133) | pub fn pairs(&self) -> Vec<(K, V)> {
  function contains_key (line 143) | pub fn contains_key<Q>(&self, key: &Q) -> bool
  function get (line 155) | pub fn get<Q>(&self, key: &Q) -> Option<V>
  function find (line 168) | pub fn find(&self, func: impl Fn(&K, &V) -> bool) -> Option<(K, V)> {
  function insert (line 178) | pub fn insert(&self, key: K, service: V) {
  function remove (line 186) | fn remove(&self, key: &K) {
  function from_iter (line 197) | fn from_iter<I>(iter: I) -> Self
  function test_pool (line 214) | async fn test_pool() {

FILE: quickwit/quickwit-common/src/tower/rate.rs
  type Rate (line 19) | pub trait Rate: Clone {
    method work (line 21) | fn work(&self) -> u64;
    method work_bytes (line 24) | fn work_bytes(&self) -> ByteSize {
    method period (line 29) | fn period(&self) -> Duration;
    method work (line 76) | fn work(&self) -> u64 {
    method period (line 80) | fn period(&self) -> Duration {
  type ConstantRate (line 34) | pub struct ConstantRate {
    method new (line 45) | pub const fn new(work: u64, period: Duration) -> Self {
    method bytes_per_period (line 50) | pub const fn bytes_per_period(bytes: ByteSize, period: Duration) -> Se...
    method bytes_per_sec (line 55) | pub const fn bytes_per_sec(bytes: ByteSize) -> Self {
    method rescale (line 65) | pub fn rescale(&self, new_period: Duration) -> Self {
  function test_rescale_zero_duration_panics (line 91) | fn test_rescale_zero_duration_panics() {
  function test_rescale_zero_duration_accepted_if_no_work (line 96) | fn test_rescale_zero_duration_accepted_if_no_work() {
  function test_rescale (line 104) | fn test_rescale() {

FILE: quickwit/quickwit-common/src/tower/rate_estimator.rs
  type RateEstimator (line 22) | pub trait RateEstimator: Rate {
    method update (line 23) | fn update(&mut self, started_at: Instant, ended_at: Instant, work: u64);
    method update (line 123) | fn update(&mut self, _started_at: Instant, ended_at: Instant, work: u6...
  type SmaRateEstimator (line 29) | pub struct SmaRateEstimator {
    method new (line 59) | pub fn new(num_buckets: NonZeroUsize, bucket_period: Duration, period:...
    method work_in_bucket (line 79) | fn work_in_bucket(&self, bucket_ord: u64) -> u64 {
    method work_at (line 84) | fn work_at(&self, now: Instant) -> u64 {
  type InnerSmaRateEstimator (line 34) | struct InnerSmaRateEstimator {
  method work (line 102) | fn work(&self) -> u64 {
  method period (line 106) | fn period(&self) -> Duration {
  function compute_bucket_ord_hash (line 112) | fn compute_bucket_ord_hash(bucket_ord: u64) -> u8 {
  type Bucket (line 137) | struct Bucket {
    method work_for_bucket (line 169) | fn work_for_bucket(&self, bucket_ord: u64) -> u64 {
    method increment_work (line 178) | fn increment_work(&self, work: u64, bucket_ord: u64) {
  constant WORK_MASK (line 144) | const WORK_MASK: u64 = (1u64 << 56) - 1;
  type BucketVal (line 146) | struct BucketVal {
    method from (line 153) | fn from(bucket_bits: u64) -> BucketVal {
  function from (line 163) | fn from(value: BucketVal) -> Self {
  function test_bucket (line 220) | fn test_bucket() {
  function test_sma_rate_estimator (line 273) | fn test_sma_rate_estimator() {
  function test_sma_rate_skipped_bucket (line 325) | fn test_sma_rate_skipped_bucket() {

FILE: quickwit/quickwit-common/src/tower/rate_limit.rs
  type RateLimit (line 31) | pub struct RateLimit<S, T> {
  type State (line 39) | enum State {
  function new (line 49) | pub fn new(inner: S, rate: T) -> Self {
  function get_ref (line 68) | pub fn get_ref(&self) -> &S {
  function get_mut (line 73) | pub fn get_mut(&mut self) -> &mut S {
  function into_inner (line 78) | pub fn into_inner(self) -> S {
  type Response (line 89) | type Response = S::Response;
  type Error (line 90) | type Error = S::Error;
  type Future (line 91) | type Future = S::Future;
  function poll_ready (line 93) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 122) | fn call(&mut self, request: R) -> Self::Future {
  type RateLimitLayer (line 162) | pub struct RateLimitLayer<T> {
  function new (line 168) | pub fn new(rate: T) -> Self {
  type Service (line 176) | type Service = RateLimit<S, T>;
  function layer (line 178) | fn layer(&self, service: S) -> Self::Service {
  type Request (line 197) | struct Request {
    method random (line 202) | fn random() -> Self {
  method cost (line 210) | fn cost(&self) -> u64 {
  type RateMeterError (line 217) | struct RateMeterError;
    method from (line 220) | fn from(_: BufferError) -> Self {
  type RateMeter (line 226) | struct RateMeter {
    method new (line 231) | fn new() -> Self {
    type Response (line 239) | type Response = ();
    type Error (line 240) | type Error = RateMeterError;
    type Future (line 241) | type Future = futures::future::Ready<Result<Self::Response, Self::Erro...
    method poll_ready (line 243) | fn poll_ready(&mut self, _: &mut Context<'_>) -> Poll<Result<(), Self:...
    method call (line 247) | fn call(&mut self, request: Request) -> Self::Future {
  function test_rate_limit_over_multiple_periods (line 255) | async fn test_rate_limit_over_multiple_periods() {
  function test_rate_limit (line 299) | async fn test_rate_limit() {

FILE: quickwit/quickwit-common/src/tower/retry.rs
  type Service (line 30) | type Service = Retry<P, S>;
  function layer (line 32) | fn layer(&self, service: S) -> Self::Service {
  type RetryLayer (line 39) | pub struct RetryLayer<P> {
  function new (line 45) | pub fn new(policy: P) -> Self {
  type RetryPolicy (line 51) | pub struct RetryPolicy {
    method from (line 57) | fn from(retry_params: RetryParams) -> Self {
    type Future (line 70) | type Future = Sleep;
    method retry (line 72) | fn retry(&mut self, _request: &mut R, result: &mut Result<T, E>) -> Op...
    method clone_request (line 95) | fn clone_request(&mut self, request: &R) -> Option<R> {
  type Retry (line 112) | pub enum Retry<E> {
  method is_retryable (line 118) | fn is_retryable(&self) -> bool {
  type HelloService (line 127) | struct HelloService;
    type Response (line 138) | type Response = ();
    type Error (line 139) | type Error = Retry<()>;
    type Future (line 140) | type Future = Ready<Result<(), Retry<()>>>;
    method poll_ready (line 142) | fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Sel...
    method call (line 146) | fn call(&mut self, request: HelloRequest) -> Self::Future {
  type HelloResults (line 129) | type HelloResults = Arc<Mutex<Vec<Result<(), Retry<()>>>>>;
  type HelloRequest (line 132) | struct HelloRequest {
  function test_retry_policy (line 159) | async fn test_retry_policy() {

FILE: quickwit/quickwit-common/src/tower/timeout.rs
  type Timeout (line 25) | pub struct Timeout<S> {
  function new (line 31) | pub fn new(service: S, timeout: Duration) -> Self {
  type Response (line 41) | type Response = S::Response;
  type Error (line 42) | type Error = S::Error;
  type Future (line 43) | type Future = TimeoutFuture<S::Future>;
    type Output (line 75) | type Output = Result<T, E>;
    method poll (line 77) | fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Outp...
  function poll_ready (line 45) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 49) | fn call(&mut self, request: R) -> Self::Future {
  type TimeoutExceeded (line 59) | pub struct TimeoutExceeded;
  type TimeoutFuture (line 63) | pub struct TimeoutFuture<F> {
  type TimeoutLayer (line 102) | pub struct TimeoutLayer {
    method new (line 108) | pub fn new(timeout: Duration) -> Self {
    type Service (line 114) | type Service = Timeout<S>;
    method layer (line 116) | fn layer(&self, service: S) -> Self::Service {
  function test_timeout (line 129) | async fn test_timeout() {

FILE: quickwit/quickwit-common/src/tower/transport.rs
  type ChangeStreamAdapter (line 41) | struct ChangeStreamAdapter<K> {
  type Item (line 51) | type Item = Result<TowerChange<K, Channel>, Infallible>;
  method poll_next (line 53) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...
  type HttpRequest (line 80) | type HttpRequest = http::Request<tonic::body::Body>;
  type HttpResponse (line 81) | type HttpResponse = http::Response<tonic::body::Body>;
  type ChangeStream (line 82) | type ChangeStream<K> = UnboundedReceiverStream<Result<TowerChange<K, Cha...
  type Discover (line 83) | type Discover<K> = PendingRequestsDiscover<ChangeStream<K>, CompleteOnRe...
  type ChannelImpl (line 84) | type ChannelImpl<K> =
  type BalanceChannel (line 88) | pub struct BalanceChannel<K: Hash + Eq + Clone + Send> {
  function new (line 96) | pub fn new() -> (Self, mpsc::UnboundedSender<Change<K, Channel>>) {
  function from_channel (line 103) | pub fn from_channel(key: K, channel: Channel) -> Self {
  function from_stream (line 107) | pub fn from_stream<S>(changes: S) -> Self
  function num_connections (line 126) | pub fn num_connections(&self) -> usize {
  function connection_keys_watcher (line 130) | pub fn connection_keys_watcher(&self) -> watch::Receiver<HashSet<K>> {
  function wait_for (line 134) | pub async fn wait_for(
  function unlazy_stream (line 153) | fn unlazy_stream<S, T>(mut inner_stream: S) -> UnboundedReceiverStream<T>
  type Response (line 173) | type Response = HttpResponse;
  type Error (line 174) | type Error = BoxError;
  type Future (line 175) | type Future = BoxFuture<HttpResponse, BoxError>;
  function poll_ready (line 177) | fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::...
  function call (line 181) | fn call(&mut self, request: HttpRequest) -> Self::Future {
  function fmt (line 189) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type KeepAliveConfig (line 197) | pub struct KeepAliveConfig {
  type ClientGrpcConfig (line 203) | pub struct ClientGrpcConfig {
  function make_channel (line 211) | pub async fn make_channel(
  function warmup_channel (line 247) | pub async fn warmup_channel(channel: Channel) {
  function test_channel_discover (line 260) | async fn test_channel_discover() {
  function test_balance_channel (line 299) | async fn test_balance_channel() {

FILE: quickwit/quickwit-common/src/type_map.rs
  type TypeMap (line 19) | pub struct TypeMap(HashMap<TypeId, Box<dyn Any + Send + Sync>>);
    method contains (line 22) | pub fn contains<T: Any + Send + Sync>(&self) -> bool {
    method insert (line 26) | pub fn insert<T: Any + Send + Sync>(&mut self, instance: T) {
    method get (line 30) | pub fn get<T: Any + Send + Sync>(&self) -> Option<&T> {
    method get_mut (line 38) | pub fn get_mut<T: Any + Send + Sync>(&mut self) -> Option<&mut T> {

FILE: quickwit/quickwit-common/src/uri.rs
  type Protocol (line 31) | pub enum Protocol {
    method as_str (line 43) | pub fn as_str(&self) -> &str {
    method is_file (line 56) | pub fn is_file(&self) -> bool {
    method is_file_storage (line 60) | pub fn is_file_storage(&self) -> bool {
    method is_object_storage (line 64) | pub fn is_object_storage(&self) -> bool {
    method is_database (line 68) | pub fn is_database(&self) -> bool {
  method fmt (line 74) | fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
  type Err (line 80) | type Err = anyhow::Error;
  method from_str (line 82) | fn from_str(protocol: &str) -> anyhow::Result<Self> {
  constant PROTOCOL_SEPARATOR (line 97) | const PROTOCOL_SEPARATOR: &str = "://";
  type Uri (line 114) | pub struct Uri {
    method for_test (line 122) | pub fn for_test(uri: &'static str) -> Self {
    method extension (line 127) | pub fn extension(&self) -> Option<&str> {
    method as_str (line 132) | pub fn as_str(&self) -> &str {
    method protocol (line 137) | pub fn protocol(&self) -> Protocol {
    method as_redacted_str (line 142) | fn as_redacted_str(&self) -> Cow<'_, str> {
    method redact (line 156) | pub fn redact(&mut self) {
    method filepath (line 162) | pub fn filepath(&self) -> Option<&Path> {
    method parent (line 172) | pub fn parent(&self) -> Option<Uri> {
    method path (line 196) | fn path(&self) -> &Path {
    method file_name (line 201) | pub fn file_name(&self) -> Option<&Path> {
    method into_string (line 220) | pub fn into_string(self) -> String {
    method join (line 226) | pub fn join<P: AsRef<Path> + std::fmt::Debug>(&self, path: P) -> anyho...
    method parse_str (line 262) | fn parse_str(uri_str: &str) -> anyhow::Result<Self> {
    method as_ref (line 305) | fn as_ref(&self) -> &str {
    method eq (line 334) | fn eq(&self, other: &&str) -> bool {
    method eq (line 340) | fn eq(&self, other: &String) -> bool {
    method deserialize (line 346) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  method fmt (line 311) | fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
  method fmt (line 320) | fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
  type Err (line 326) | type Err = anyhow::Error;
  method from_str (line 328) | fn from_str(uri_str: &str) -> anyhow::Result<Self> {
  method serialize (line 355) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  function normalize_path (line 366) | fn normalize_path(path: &Path) -> PathBuf {
  function test_try_new_uri (line 399) | fn test_try_new_uri() {
  function test_uri_protocol (line 501) | fn test_uri_protocol() {
  function test_uri_extension (line 524) | fn test_uri_extension() {
  function test_uri_join (line 538) | fn test_uri_join() {
  function test_uri_parent (line 579) | fn test_uri_parent() {
  function test_uri_file_name (line 669) | fn test_uri_file_name() {
  function test_uri_filepath (line 741) | fn test_uri_filepath() {
  function test_uri_as_redacted_str (line 770) | fn test_uri_as_redacted_str() {
  function test_uri_serialize (line 810) | fn test_uri_serialize() {

FILE: quickwit/quickwit-config/src/cluster_config/mod.rs
  type ClusterConfig (line 21) | pub struct ClusterConfig {
    method for_test (line 32) | pub fn for_test() -> Self {

FILE: quickwit/quickwit-config/src/config_value.rs
  type ConfigValue (line 26) | pub(crate) struct ConfigValue<T, const E: usize> {
  function with_default (line 38) | pub(crate) fn with_default(value: T) -> Self {
  function none (line 45) | pub(crate) fn none() -> Self {
  function for_test (line 53) | pub(crate) fn for_test(value: T) -> Self {
  function unwrap (line 61) | pub(crate) fn unwrap(self) -> T {
  function resolve_optional (line 65) | pub(crate) fn resolve_optional(
  function resolve (line 96) | pub(crate) fn resolve(self, env_vars: &HashMap<String, String>) -> anyho...
  method default (line 107) | fn default() -> Self {
  function deserialize (line 118) | fn deserialize<D>(deserializer: D) -> Result<ConfigValue<T, E>, D::Error>
  function test_config_value_resolve_optional (line 136) | fn test_config_value_resolve_optional() {
  function test_config_value_resolve (line 199) | fn test_config_value_resolve() {
  function test_config_value_resolve_optional_empty_string (line 206) | fn test_config_value_resolve_optional_empty_string() {
  function test_config_value_deserialize (line 214) | fn test_config_value_deserialize() {

FILE: quickwit/quickwit-config/src/index_config/mod.rs
  type IndexingResources (line 43) | pub struct IndexingResources {
    method default_heap_size (line 68) | fn default_heap_size() -> ByteSize {
    method for_test (line 73) | pub fn for_test() -> Self {
    method validate (line 80) | pub fn validate(&self) -> anyhow::Result<()> {
  method eq (line 56) | fn eq(&self, other: &Self) -> bool {
  method hash (line 62) | fn hash<H: Hasher>(&self, state: &mut H) {
  method default (line 92) | fn default() -> Self {
  type IndexingSettings (line 102) | pub struct IndexingSettings {
    method commit_timeout (line 126) | pub fn commit_timeout(&self) -> Duration {
    method default_commit_timeout_secs (line 130) | fn default_commit_timeout_secs() -> usize {
    method default_docstore_blocksize (line 134) | pub fn default_docstore_blocksize() -> usize {
    method default_docstore_compression_level (line 138) | pub fn default_docstore_compression_level() -> i32 {
    method default_split_num_docs_target (line 142) | pub fn default_split_num_docs_target() -> usize {
    method for_test (line 147) | pub fn for_test() -> Self {
  method default (line 156) | fn default() -> Self {
  type IngestSettings (line 171) | pub struct IngestSettings {
    method default_min_shards (line 189) | pub fn default_min_shards() -> NonZeroUsize {
  method default (line 195) | fn default() -> Self {
  type SearchSettings (line 205) | pub struct SearchSettings {
  type RetentionPolicy (line 212) | pub struct RetentionPolicy {
    method default_schedule (line 227) | pub fn default_schedule() -> String {
    method retention_period (line 231) | pub fn retention_period(&self) -> anyhow::Result<Duration> {
    method evaluation_schedule (line 240) | pub fn evaluation_schedule(&self) -> anyhow::Result<Schedule> {
    method duration_until_next_evaluation (line 251) | pub fn duration_until_next_evaluation(&self) -> anyhow::Result<Duratio...
    method validate (line 263) | pub(super) fn validate(&self) -> anyhow::Result<()> {
  function prepend_at_char (line 272) | fn prepend_at_char(schedule: &str) -> String {
  type IndexConfig (line 288) | pub struct IndexConfig {
    method indexing_params_fingerprint (line 304) | pub(crate) fn indexing_params_fingerprint(&self) -> u64 {
    method equals_fingerprint (line 317) | pub fn equals_fingerprint(&self, other: &Self) -> bool {
    method for_test (line 322) | pub fn for_test(index_id: &str, index_uri: &str) -> Self {
    method sample_for_regression (line 411) | fn sample_for_regression() -> Self {
    method assert_equality (line 518) | fn assert_equality(&self, other: &Self) {
  function build_doc_mapper (line 530) | pub fn build_doc_mapper(
  function validate_index_config (line 545) | pub(super) fn validate_index_config(
  function prepare_doc_mapping_update (line 582) | pub fn prepare_doc_mapping_update(
  function get_index_config_filepath (line 636) | fn get_index_config_filepath(index_config_filename: &str) -> String {
  function test_index_config_parse_aux (line 645) | fn test_index_config_parse_aux(config_format: ConfigFormat) {
  function test_index_config_from_json (line 716) | fn test_index_config_from_json() {
  function test_index_config_from_toml (line 721) | fn test_index_config_from_toml() {
  function test_index_config_from_yaml (line 726) | fn test_index_config_from_yaml() {
  function test_indexer_config_default_values (line 731) | fn test_indexer_config_default_values() {
  function test_config_validates_uris (line 795) | fn test_config_validates_uris() {
  function test_minimal_index_config_default_dynamic (line 806) | fn test_minimal_index_config_default_dynamic() {
  function test_index_config_with_malformed_maturation_duration (line 826) | fn test_index_config_with_malformed_maturation_duration() {
  function test_retention_policy_serialization (line 853) | fn test_retention_policy_serialization() {
  function test_retention_policy_deserialization (line 866) | fn test_retention_policy_deserialization() {
  function test_parse_retention_policy_period (line 897) | fn test_parse_retention_policy_period() {
  function test_prepend_at_char (line 921) | fn test_prepend_at_char() {
  function test_parse_retention_policy_schedule (line 929) | fn test_parse_retention_policy_schedule() {
  function test_retention_policy_validate (line 963) | fn test_retention_policy_validate() {
  function test_retention_schedule_duration (line 988) | fn test_retention_schedule_duration() {
  function test_ingest_settings_serde (line 1015) | fn test_ingest_settings_serde() {
  function test_prepare_doc_mapping_update (line 1044) | fn test_prepare_doc_mapping_update() {

FILE: quickwit/quickwit-config/src/index_config/serialize.rs
  type IndexConfigForSerialization (line 28) | type IndexConfigForSerialization = IndexConfigV0_8;
    method from (line 44) | fn from(versioned_config: VersionedIndexConfig) -> IndexConfigForSeria...
    method index_uri_or_fallback_to_default (line 103) | fn index_uri_or_fallback_to_default(
    method build_and_validate (line 121) | pub fn build_and_validate(
  type VersionedIndexConfig (line 32) | pub(crate) enum VersionedIndexConfig {
    method from (line 149) | fn from(index_config: IndexConfig) -> Self {
  function load_index_config_from_user_config (line 54) | pub fn load_index_config_from_user_config(
  function load_index_config_update (line 69) | pub fn load_index_config_update(
  type Error (line 155) | type Error = anyhow::Error;
  method try_from (line 157) | fn try_from(versioned_index_config: VersionedIndexConfig) -> anyhow::Res...
  type IndexConfigV0_8 (line 171) | pub struct IndexConfigV0_8 {
    method from (line 190) | fn from(index_config: IndexConfig) -> Self {
  function minimal_index_config_for_serialization (line 208) | fn minimal_index_config_for_serialization() -> IndexConfigForSerializati...
  function test_validate_invalid_merge_policy (line 229) | fn test_validate_invalid_merge_policy() {
  function test_validate_retention_policy (line 251) | fn test_validate_retention_policy() {
  function test_minimal_index_config_missing_root_uri_no_default_uri (line 267) | fn test_minimal_index_config_missing_root_uri_no_default_uri() {
  function test_minimal_index_config_missing_root_uri_with_default_index_root_uri (line 279) | fn test_minimal_index_config_missing_root_uri_with_default_index_root_ur...
  function test_update_index_root_uri (line 298) | fn test_update_index_root_uri() {
  function test_update_reset_defaults (line 364) | fn test_update_reset_defaults() {
  function test_update_doc_mappings (line 422) | fn test_update_doc_mappings() {
  function test_update_doc_mappings_failing_cases (line 457) | fn test_update_doc_mappings_failing_cases() {

FILE: quickwit/quickwit-config/src/index_template/mod.rs
  type IndexTemplateId (line 29) | pub type IndexTemplateId = String;
  type IndexIdPattern (line 30) | pub type IndexIdPattern = String;
  type IndexTemplate (line 35) | pub struct IndexTemplate {
    method apply_template (line 57) | pub fn apply_template(
    method validate (line 84) | pub fn validate(&self) -> anyhow::Result<()> {
    method for_test (line 104) | pub fn for_test(template_id: &str, index_id_patterns: &[&str], priorit...
    method sample_for_regression (line 143) | fn sample_for_regression() -> Self {
    method assert_equality (line 184) | fn assert_equality(&self, other: &Self) {
  function test_index_template_serde (line 194) | fn test_index_template_serde() {
  function test_index_template_apply (line 226) | fn test_index_template_apply() {
  function test_index_template_validate (line 277) | fn test_index_template_validate() {

FILE: quickwit/quickwit-config/src/index_template/serialize.rs
  type VersionedIndexTemplate (line 24) | pub enum VersionedIndexTemplate {
    method from (line 69) | fn from(index_template: IndexTemplate) -> Self {
  type IndexTemplateV0_8 (line 33) | pub struct IndexTemplateV0_8 {
    method from (line 92) | fn from(index_template: IndexTemplate) -> Self {
  method from (line 61) | fn from(versioned_index_template: VersionedIndexTemplate) -> Self {
  method from (line 75) | fn from(index_template_v0_8: IndexTemplateV0_8) -> Self {

FILE: quickwit/quickwit-config/src/lib.rs
  function enable_ingest_v2 (line 87) | pub fn enable_ingest_v2() -> bool {
  function disable_ingest_v1 (line 94) | pub fn disable_ingest_v1() -> bool {
  type ConfigApiSchemas (line 135) | pub struct ConfigApiSchemas;
  function validate_identifier (line 138) | pub fn validate_identifier(label: &str, value: &str) -> anyhow::Result<(...
  function validate_index_id_pattern (line 153) | pub fn validate_index_id_pattern(pattern: &str, allow_negative: bool) ->...
  function validate_node_id (line 192) | pub fn validate_node_id(node_id: &NodeIdRef) -> anyhow::Result<()> {
  type ConfigFormat (line 203) | pub enum ConfigFormat {
    method as_str (line 210) | pub fn as_str(&self) -> &'static str {
    method sniff_from_uri (line 218) | pub fn sniff_from_uri(uri: &Uri) -> anyhow::Result<ConfigFormat> {
    method parse (line 229) | pub fn parse<T>(&self, payload: &[u8]) -> anyhow::Result<T>
  type Err (line 266) | type Err = anyhow::Error;
  method from_str (line 268) | fn from_str(ext: &str) -> anyhow::Result<Self> {
  type TestableForRegression (line 281) | pub trait TestableForRegression: Serialize + DeserializeOwned {
    method sample_for_regression (line 284) | fn sample_for_regression() -> Self;
    method assert_equality (line 287) | fn assert_equality(&self, other: &Self);
  function indexing_pipeline_params_fingerprint (line 292) | pub fn indexing_pipeline_params_fingerprint(
  function test_validate_identifier (line 308) | fn test_validate_identifier() {
  function test_validate_index_id_pattern (line 330) | fn test_validate_index_id_pattern() {

FILE: quickwit/quickwit-config/src/merge_policy_config.rs
  function is_zero (line 19) | fn is_zero(value: &usize) -> bool {
  type ConstWriteAmplificationMergePolicyConfig (line 25) | pub struct ConstWriteAmplificationMergePolicyConfig {
  method default (line 56) | fn default() -> ConstWriteAmplificationMergePolicyConfig {
  type StableLogMergePolicyConfig (line 70) | pub struct StableLogMergePolicyConfig {
  function default_merge_factor (line 91) | fn default_merge_factor() -> usize {
  function default_max_merge_factor (line 95) | fn default_max_merge_factor() -> usize {
  function default_max_merge_ops (line 99) | fn default_max_merge_ops() -> usize {
  function default_min_level_num_docs (line 103) | fn default_min_level_num_docs() -> usize {
  function default_maturation_period (line 107) | fn default_maturation_period() -> Duration {
  method default (line 112) | fn default() -> Self {
  function parse_human_duration (line 122) | fn parse_human_duration<'de, D>(deserializer: D) -> Result<Duration, D::...
  function serialize_duration (line 133) | fn serialize_duration<S>(value: &Duration, s: S) -> Result<S::Ok, S::Error>
  type MergePolicyConfig (line 142) | pub enum MergePolicyConfig {
    method noop (line 159) | pub fn noop() -> Self {
    method validate (line 163) | pub fn validate(&self) -> anyhow::Result<()> {
  method default (line 153) | fn default() -> Self {

FILE: quickwit/quickwit-config/src/metastore_config.rs
  type MetastoreBackend (line 27) | pub enum MetastoreBackend {
  type MetastoreConfigs (line 45) | pub struct MetastoreConfigs(#[serde_as(as = "EnumMap")] Vec<MetastoreCon...
    method redact (line 48) | pub fn redact(&mut self) {
    method validate (line 54) | pub fn validate(&self) -> anyhow::Result<()> {
    method find_file (line 74) | pub fn find_file(&self) -> Option<&FileMetastoreConfig> {
    method find_postgres (line 83) | pub fn find_postgres(&self) -> Option<&PostgresMetastoreConfig> {
  type Target (line 96) | type Target = Vec<MetastoreConfig>;
  method deref (line 98) | fn deref(&self) -> &Self::Target {
  type MetastoreConfig (line 105) | pub enum MetastoreConfig {
    method backend (line 112) | pub fn backend(&self) -> MetastoreBackend {
    method as_file (line 119) | pub fn as_file(&self) -> Option<&FileMetastoreConfig> {
    method as_postgres (line 126) | pub fn as_postgres(&self) -> Option<&PostgresMetastoreConfig> {
    method redact (line 133) | pub fn redact(&mut self) {
    method validate (line 138) | pub fn validate(&self) -> anyhow::Result<()> {
    method from (line 148) | fn from(file_metastore_config: FileMetastoreConfig) -> Self {
    method from (line 154) | fn from(postgres_metastore_config: PostgresMetastoreConfig) -> Self {
  type PostgresMetastoreConfig (line 161) | pub struct PostgresMetastoreConfig {
    method default_min_connections (line 190) | pub fn default_min_connections() -> usize {
    method default_max_connections (line 194) | pub fn default_max_connections() -> NonZeroUsize {
    method default_acquire_connection_timeout (line 198) | pub fn default_acquire_connection_timeout() -> String {
    method default_idle_connection_timeout (line 202) | pub fn default_idle_connection_timeout() -> String {
    method default_max_connection_lifetime (line 206) | pub fn default_max_connection_lifetime() -> String {
    method acquire_connection_timeout (line 210) | pub fn acquire_connection_timeout(&self) -> anyhow::Result<Duration> {
    method idle_connection_timeout_opt (line 219) | pub fn idle_connection_timeout_opt(&self) -> anyhow::Result<Option<Dur...
    method max_connection_lifetime_opt (line 237) | pub fn max_connection_lifetime_opt(&self) -> anyhow::Result<Option<Dur...
    method validate (line 255) | pub fn validate(&self) -> anyhow::Result<()> {
  method default (line 178) | fn default() -> Self {
  type FileMetastoreConfig (line 269) | pub struct FileMetastoreConfig;
    method validate (line 272) | pub fn validate(&self) -> anyhow::Result<()> {
  function test_metastore_configs_serde (line 282) | fn test_metastore_configs_serde() {
  function test_metastore_configs_validate (line 306) | fn test_metastore_configs_validate() {
  function test_pg_metastore_config_serde (line 334) | fn test_pg_metastore_config_serde() {

FILE: quickwit/quickwit-config/src/node_config/mod.rs
  constant DEFAULT_QW_CONFIG_PATH (line 44) | pub const DEFAULT_QW_CONFIG_PATH: &str = "config/quickwit.yaml";
  type RestConfig (line 48) | pub struct RestConfig {
  type GrpcConfig (line 59) | pub struct GrpcConfig {
    method default_max_message_size (line 103) | fn default_max_message_size() -> ByteSize {
    method validate (line 107) | pub fn validate(&self) -> anyhow::Result<()> {
  function default_http2_keep_alive_interval (line 70) | fn default_http2_keep_alive_interval() -> DurationAsStr {
  function default_keep_alive_timeout (line 74) | fn default_keep_alive_timeout() -> DurationAsStr {
  type KeepAliveConfig (line 79) | pub struct KeepAliveConfig {
  function from (line 94) | fn from(val: KeepAliveConfig) -> Self {
  method default (line 118) | fn default() -> Self {
  type TlsConfig (line 129) | pub struct TlsConfig {
  type IndexerConfig (line 142) | pub struct IndexerConfig {
    method default_enable_cooperative_indexing (line 169) | fn default_enable_cooperative_indexing() -> bool {
    method default_enable_otlp_endpoint (line 173) | fn default_enable_otlp_endpoint() -> bool {
    method default_max_concurrent_split_uploads (line 184) | fn default_max_concurrent_split_uploads() -> usize {
    method default_split_store_max_num_bytes (line 188) | pub fn default_split_store_max_num_bytes() -> ByteSize {
    method default_split_store_max_num_splits (line 192) | pub fn default_split_store_max_num_splits() -> usize {
    method default_merge_concurrency (line 196) | pub fn default_merge_concurrency() -> NonZeroUsize {
    method default_cpu_capacity (line 200) | fn default_cpu_capacity() -> CpuCapacity {
    method for_test (line 205) | pub fn for_test() -> anyhow::Result<Self> {
  method default (line 222) | fn default() -> Self {
  type SplitCacheLimits (line 238) | pub struct SplitCacheLimits {
    method default_max_num_splits (line 249) | fn default_max_num_splits() -> NonZeroU32 {
    method default_num_concurrent_downloads (line 253) | fn default_num_concurrent_downloads() -> NonZeroU32 {
    method default_max_file_descriptors (line 257) | fn default_max_file_descriptors() -> NonZeroU32 {
  type SearcherConfig (line 264) | pub struct SearcherConfig {
    method request_timeout (line 532) | pub fn request_timeout(&self) -> Duration {
    method default_request_timeout_secs (line 535) | fn default_request_timeout_secs() -> NonZeroU64 {
    method validate (line 538) | fn validate(&self) -> anyhow::Result<()> {
  type LambdaConfig (line 316) | pub struct LambdaConfig {
    method for_test (line 338) | pub fn for_test() -> Self {
    method default_function_name (line 347) | fn default_function_name() -> String {
    method default_max_splits_per_invocation (line 350) | fn default_max_splits_per_invocation() -> NonZeroUsize {
    method default_offload_threshold (line 353) | fn default_offload_threshold() -> usize {
  type LambdaDeployConfig (line 361) | pub struct LambdaDeployConfig {
    method default_memory_size (line 375) | fn default_memory_size() -> ByteSize {
    method default_invocation_timeout_secs (line 379) | fn default_invocation_timeout_secs() -> u64 {
  type CacheConfig (line 386) | pub struct CacheConfig {
    method no_cache (line 398) | pub fn no_cache() -> Self {
    method default_with_capacity (line 406) | pub fn default_with_capacity(capacity: ByteSize) -> Self {
    method capacity (line 414) | pub fn capacity(&self) -> ByteSize {
    method capacity_for_virtual_cache (line 419) | pub fn capacity_for_virtual_cache(&mut self, real_capacity: ByteSize) ...
    method policy (line 425) | pub fn policy(&self) -> CachePolicy {
    method policy_for_virtual_cache (line 429) | pub fn policy_for_virtual_cache(&mut self, real_policy: CachePolicy) -...
    method deserialize_with_default (line 435) | fn deserialize_with_default<'de, D, const DEFAULT_CAPACITY: u64>(
    method from (line 451) | fn from(capacity: ByteSize) -> Self {
  type CachePolicy (line 458) | pub enum CachePolicy {
    method fmt (line 466) | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  type StorageTimeoutPolicy (line 487) | pub struct StorageTimeoutPolicy {
    method compute_timeout (line 496) | pub fn compute_timeout(&self, num_bytes: usize) -> impl Iterator<Item ...
  method default (line 509) | fn default() -> Self {
  type CompressionAlgorithm (line 565) | pub enum CompressionAlgorithm {
  type IngestApiConfig (line 572) | pub struct IngestApiConfig {
    method replication_factor (line 611) | pub fn replication_factor(&self) -> anyhow::Result<NonZeroUsize> {
    method grpc_compression_encoding (line 632) | pub fn grpc_compression_encoding(&self) -> Option<CompressionEncoding> {
    method validate (line 641) | fn validate(&self) -> anyhow::Result<()> {
  method default (line 594) | fn default() -> Self {
  type JaegerConfig (line 684) | pub struct JaegerConfig {
    method lookback_period (line 708) | pub fn lookback_period(&self) -> Duration {
    method max_trace_duration (line 712) | pub fn max_trace_duration(&self) -> Duration {
    method default_enable_endpoint (line 716) | fn default_enable_endpoint() -> bool {
    method default_lookback_period_hours (line 727) | fn default_lookback_period_hours() -> NonZeroU64 {
    method default_max_trace_duration_secs (line 731) | fn default_max_trace_duration_secs() -> NonZeroU64 {
    method default_max_fetch_spans (line 735) | fn default_max_fetch_spans() -> NonZeroU64 {
  method default (line 741) | fn default() -> Self {
  type NodeConfig (line 752) | pub struct NodeConfig {
    method is_service_enabled (line 777) | pub fn is_service_enabled(&self, service: QuickwitService) -> bool {
    method load (line 782) | pub async fn load(config_format: ConfigFormat, config_content: &[u8]) ...
    method peer_seed_addrs (line 796) | pub async fn peer_seed_addrs(&self) -> anyhow::Result<Vec<String>> {
    method redact (line 820) | pub fn redact(&mut self) {
    method for_test (line 830) | pub fn for_test() -> Self {
    method for_test_from_ports (line 835) | pub fn for_test_from_ports(rest_listen_port: u16, grpc_listen_port: u1...
  function test_indexer_config_serialization (line 848) | fn test_indexer_config_serialization() {
  function test_validate_ingest_api_default (line 909) | fn test_validate_ingest_api_default() {
  function test_validate_ingest_api_config (line 916) | fn test_validate_ingest_api_config() {
  function test_keepalive_config_serialization_aux (line 963) | fn test_keepalive_config_serialization_aux(
  function test_keepalive_config_serialization (line 981) | fn test_keepalive_config_serialization() {
  function test_grpc_config_serialization_default (line 1002) | fn test_grpc_config_serialization_default() {
  function test_grpc_config_validate (line 1019) | fn test_grpc_config_validate() {

FILE: quickwit/quickwit-config/src/node_config/serialize.rs
  constant DEFAULT_CLUSTER_ID (line 42) | pub const DEFAULT_CLUSTER_ID: &str = "quickwit-default-cluster";
  constant DEFAULT_DATA_DIR_PATH (line 44) | pub const DEFAULT_DATA_DIR_PATH: &str = "qwdata";
  constant DEFAULT_GOSSIP_INTERVAL (line 46) | pub const DEFAULT_GOSSIP_INTERVAL: Duration = if cfg!(any(test, feature ...
  function default_cluster_id (line 53) | fn default_cluster_id() -> ConfigValue<String, QW_CLUSTER_ID> {
  function default_node_id (line 57) | fn default_node_id() -> ConfigValue<String, QW_NODE_ID> {
  function default_availability_zone (line 69) | fn default_availability_zone() -> ConfigValue<String, QW_AVAILABILITY_ZO...
  type List (line 74) | struct List(Vec<String>);
  type Err (line 77) | type Err = anyhow::Error;
  method from_str (line 79) | fn from_str(list_str: &str) -> Result<Self, Self::Err> {
  function default_enabled_services (line 89) | fn default_enabled_services() -> ConfigValue<List, QW_ENABLED_SERVICES> {
  function default_listen_address (line 98) | fn default_listen_address() -> ConfigValue<String, QW_LISTEN_ADDRESS> {
  function default_rest_listen_port (line 102) | fn default_rest_listen_port() -> u16 {
  function default_data_dir_uri (line 106) | fn default_data_dir_uri() -> ConfigValue<Uri, QW_DATA_DIR> {
  function default_advertise_host (line 111) | fn default_advertise_host(listen_ip: &IpAddr) -> anyhow::Result<Host> {
  function default_metastore_uri (line 129) | fn default_metastore_uri(data_dir_uri: &Uri) -> Uri {
  function default_index_root_uri (line 134) | fn default_index_root_uri(data_dir_uri: &Uri) -> Uri {
  function load_node_config_with_env (line 138) | pub async fn load_node_config_with_env(
  type VersionedNodeConfig (line 153) | enum VersionedNodeConfig {
  type NodeConfigBuilder (line 171) | struct NodeConfigBuilder {
    method from (line 161) | fn from(versioned_node_config: VersionedNodeConfig) -> Self {
    method build_and_validate (line 222) | pub async fn build_and_validate(
  function validate (line 341) | fn validate(node_config: &NodeConfig) -> anyhow::Result<()> {
  type ExpectedDiskUsage (line 360) | struct ExpectedDiskUsage {
    method from_config (line 369) | fn from_config(node_config: &NodeConfig) -> Self {
    method total (line 386) | fn total(&self) -> ByteSize {
  function validate_disk_usage (line 393) | fn validate_disk_usage(node_config: &NodeConfig) {
  method default (line 408) | fn default() -> Self {
  type RestConfigBuilder (line 439) | struct RestConfigBuilder {
    method build_and_validate (line 453) | fn build_and_validate(
  function node_config_for_tests_from_ports (line 475) | pub fn node_config_for_tests_from_ports(
  function get_config_filepath (line 548) | fn get_config_filepath(config_filename: &str) -> String {
  function test_node_config_parse_aux (line 556) | async fn test_node_config_parse_aux(config_format: ConfigFormat) -> anyh...
  function test_node_config_parse_json (line 716) | async fn test_node_config_parse_json() {
  function test_node_config_parse_toml (line 723) | async fn test_node_config_parse_toml() {
  function test_node_config_parse_yaml (line 730) | async fn test_node_config_parse_yaml() {
  function test_config_contains_wrong_values (line 737) | async fn test_config_contains_wrong_values() {
  function test_node_config_default_values_minimal (line 754) | async fn test_node

[
  {
    "path": ".cargo/config.toml",
    "chars": 506,
    "preview": "[build]\nrustflags = [\"--cfg\", \"tokio_unstable\"]\nrustdocflags = [\"--cfg\", \"tokio_unstable\"]\n\n[target.x86_64-unknown-linux"
  },
  {
    "path": ".claude/skills/bump-tantivy/SKILL.md",
    "chars": 2200,
    "preview": "---\nname: bump-tantivy\ndescription: Bump tantivy to the latest commit on main branch, fix compilation issues, and open a"
  },
  {
    "path": ".claude/skills/fix-clippy/SKILL.md",
    "chars": 530,
    "preview": "---\nname: fix-clippy\ndescription: Fix all clippy lint warnings in the project\n---\n\n# Fix Clippy\n\nClippy issues are **war"
  },
  {
    "path": ".claude/skills/fmt/SKILL.md",
    "chars": 570,
    "preview": "---\nname: fmt\ndescription: Run `make fmt` to check the code format.\n---\n\n# Format Check\n\nRun `make fmt` from the `quickw"
  },
  {
    "path": ".claude/skills/rationalize-deps/SKILL.md",
    "chars": 3463,
    "preview": "---\nname: rationalize-deps\ndescription: Analyze Cargo.toml dependencies and attempt to remove unused features to reduce "
  },
  {
    "path": ".claude/skills/simple-pr/SKILL.md",
    "chars": 1718,
    "preview": "---\nname: simple-pr\ndescription: Create a simple PR from staged changes with an auto-generated commit message\ndisable-mo"
  },
  {
    "path": ".devcontainer/devcontainer.json",
    "chars": 1015,
    "preview": "{\n    \"name\": \"Quickwit\",\n    \"image\": \"mcr.microsoft.com/devcontainers/rust:bookworm\",\n    \"customizations\": {\n        "
  },
  {
    "path": ".devcontainer/post-create.sh",
    "chars": 2020,
    "preview": "#!/bin/bash\n\n# Define success and error color codes\nSUCCESS_COLOR=\"\\e[32m\"\nERROR_COLOR=\"\\e[31m\"\nRESET_COLOR=\"\\e[0m\"\n\n# D"
  },
  {
    "path": ".devcontainer/welcome.txt",
    "chars": 870,
    "preview": "👋 Welcome to the project!\nAll the necessary tools have already been installed for you 🎉. \nYou can go ahead and start hac"
  },
  {
    "path": ".dockerignore",
    "chars": 177,
    "preview": "**/*.md\n**/*.txt\n**/.*\n**/build\n**/Dockerfile\n**/node_modules\n**/qwdata\n**/target\ndocs\nexamples\n!.git/\n!quickwit-ui/buil"
  },
  {
    "path": ".gitattributes",
    "chars": 33,
    "preview": "**/codegen/** linguist-generated\n"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug_report.md",
    "chars": 440,
    "preview": "---\nname: Bug report\nabout: Create a report to help us improve\ntitle: \"\"\nlabels: bug\nassignees: \"\"\n---\n\n**Describe the b"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/documentation_request.md",
    "chars": 636,
    "preview": "---\nname: Documentation request\nabout: Suggest a documentation enhancement\ntitle: \"[Documentation topic]\"\nlabels: docume"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature_request.md",
    "chars": 603,
    "preview": "---\nname: Feature request\nabout: Suggest an idea for this project\ntitle: \"\"\nlabels: enhancement\nassignees: \"\"\n---\n\n**Is "
  },
  {
    "path": ".github/ISSUE_TEMPLATE/tutorial_request.md",
    "chars": 797,
    "preview": "---\nname: Tutorial request\nabout: Suggest a Quickwit tutorial\ntitle: \"[Tutorial topic]\"\nlabels: tutorial\nassignees: \"\"\n-"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 127,
    "preview": "### Description\n\nDescribe the proposed changes made in this PR.\n\n### How was this PR tested?\n\nDescribe how you tested th"
  },
  {
    "path": ".github/actions/cargo-build-macos-binary/action.yml",
    "chars": 2619,
    "preview": "name: \"Build Quickwit binary for macOS\"\ndescription: \"Build React app and Rust binary for macOS with cargo build.\"\ninput"
  },
  {
    "path": ".github/actions/cross-build-binary/action.yml",
    "chars": 2443,
    "preview": "name: \"Build Quickwit binary with cargo cross\"\ndescription: \"Build React app and Rust binary with cargo cross.\"\ninputs:\n"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 913,
    "preview": "version: 2\nupdates:\n  # Rust dependencies\n  - package-ecosystem: cargo\n    directory: \"/quickwit\"\n    schedule:\n      in"
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 8246,
    "preview": "name: CI\n\non:\n  workflow_dispatch:\n  pull_request:\n  push:\n    branches:\n      - main\n      - trigger-ci-workflow\n    pa"
  },
  {
    "path": ".github/workflows/coverage.yml",
    "chars": 7413,
    "preview": "name: Code coverage\n\non:\n  workflow_dispatch:\n  push:\n    branches:\n      - main\n      - trigger-coverage-workflow\n    p"
  },
  {
    "path": ".github/workflows/dependency.yml",
    "chars": 754,
    "preview": "name: \"Dependency Review\"\non: [pull_request]\n\npermissions:\n  contents: read\n\n# Ensures that we cancel running jobs for t"
  },
  {
    "path": ".github/workflows/publish_cross_images.yml",
    "chars": 741,
    "preview": "name: Publish custom cross images\n\non:\n  workflow_dispatch:\n  push:\n    branches:\n      - main\n    paths:\n      - \"build"
  },
  {
    "path": ".github/workflows/publish_docker_images.yml",
    "chars": 5593,
    "preview": "name: Build and publish Docker images\n\non:\n  workflow_dispatch:\n  push:\n    branches:\n      - main\n      - release-0.9\n "
  },
  {
    "path": ".github/workflows/publish_lambda.yaml",
    "chars": 2888,
    "preview": "# This workflow creates a new release for a quickwit search aws lambda.\n# The artifact is a zip file containing a binary"
  },
  {
    "path": ".github/workflows/publish_nightly_packages.yml",
    "chars": 1210,
    "preview": "name: Build and publish nightly packages\n\non:\n  workflow_dispatch:\n  schedule:\n    - cron: \"0 5 * * *\"\n\npermissions:\n  c"
  },
  {
    "path": ".github/workflows/publish_release_packages.yml",
    "chars": 1400,
    "preview": "name: Build and publish release packages\n\non:\n  push:\n    tags:\n      - \"v*\"\n\npermissions:\n  contents: read\n\njobs:\n  bui"
  },
  {
    "path": ".github/workflows/requirements.txt",
    "chars": 1414,
    "preview": "# contains pinned dependencies for installing pipenv to ensure repeatable builds in CI/CD workflows\ncertifi==2025.10.5 \\"
  },
  {
    "path": ".github/workflows/scorecard.yml",
    "chars": 1386,
    "preview": "name: OpenSSF Scorecard\non:\n  schedule:\n    - cron: '0 0 * * 0'\n  push:\n    branches:\n      - main\n\npermissions:\n  conte"
  },
  {
    "path": ".github/workflows/ui-ci.yml",
    "chars": 3457,
    "preview": "name: UI CI\n\non:\n  workflow_dispatch:\n  pull_request:\n    paths:\n      - \"quickwit/quickwit-ui/**\"\n      - \".github/work"
  },
  {
    "path": ".gitignore",
    "chars": 590,
    "preview": "# Generated by Cargo\n# will have compiled files and executables\n**/target/**\n**/proptest-regressions\n**/perf.data*\n**/fl"
  },
  {
    "path": ".localstack/init.sh",
    "chars": 333,
    "preview": "#!/usr/bin/env bash\n\nset -eu\n\nawslocal s3 mb s3://quickwit-dev\nawslocal s3 mb s3://quickwit-integration-tests && awsloca"
  },
  {
    "path": "CHANGELOG.md",
    "chars": 17684,
    "preview": "<!--\n# Changelog\nAll notable changes to this project will be documented in this file.\n\nThe format is based on [Keep a Ch"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 5494,
    "preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nWe as members, contributors, and leaders pledge to make participa"
  },
  {
    "path": "CODE_STYLE.md",
    "chars": 9403,
    "preview": "# Quickwit Coding Style\n\nThis document resumes a couple of points we try to embrace in our coding style. Some of these p"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 7963,
    "preview": "# Contributing to Quickwit\nThere are many ways to contribute to Quickwit.\nCode contributions are welcome of course, but "
  },
  {
    "path": "Dockerfile",
    "chars": 2266,
    "preview": "FROM node:24@sha256:b2b2184ba9b78c022e1d6a7924ec6fba577adf28f15c9d9c457730cc4ad3807a AS ui-builder\n\nCOPY quickwit/quickw"
  },
  {
    "path": "LICENSE",
    "chars": 11351,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "LICENSE-3rdparty.csv",
    "chars": 64502,
    "preview": "Component,Origin,License,Copyright\nadler2,https://github.com/oyvindln/adler2,0BSD OR MIT OR Apache-2.0,\"Jonas Schievink "
  },
  {
    "path": "Makefile",
    "chars": 3460,
    "preview": "DOCKER_SERVICES ?= all\n\nQUICKWIT_SRC = quickwit\n\nhelp:\n\t@grep '^[^\\.#[:space:]].*:' Makefile\n\n\nIMAGE_TAG := $(shell git "
  },
  {
    "path": "README.md",
    "chars": 8791,
    "preview": "[![CI](https://github.com/quickwit-oss/quickwit/actions/workflows/ci.yml/badge.svg)](https://github.com/quickwit-oss/qui"
  },
  {
    "path": "SECURITY.md",
    "chars": 701,
    "preview": "# Security Policy\n\n## Supported Versions\n\n| Version | Supported          |\n| ------- | ------------------ |\n| 0.3.1   | "
  },
  {
    "path": "_typos.toml",
    "chars": 113,
    "preview": "[files]\nextend-exclude = [\"**/*.json\"]\n\n[default.extend-words]\n# Don't correct the surname \"Teh\"\nstrat = \"strat\"\n"
  },
  {
    "path": "build/cross-images/aarch64-unknown-linux-gnu.dockerfile",
    "chars": 1069,
    "preview": "FROM ghcr.io/cross-rs/aarch64-unknown-linux-gnu:0.2.4@sha256:3356619b020614effd22e83cec41236e69f17ce581ffe35e252898b0c69"
  },
  {
    "path": "build/cross-images/aarch64-unknown-linux-musl.dockerfile",
    "chars": 2107,
    "preview": "FROM rustembedded/cross:aarch64-unknown-linux-musl@sha256:22627e0ba533781062127b13601c37216fdca27123390b07dfabd3f31f3c84"
  },
  {
    "path": "build/cross-images/x86_64-unknown-linux-gnu.dockerfile",
    "chars": 580,
    "preview": "FROM ghcr.io/cross-rs/x86_64-unknown-linux-gnu:0.2.4@sha256:7c9067212c2283be2a1d5585af5ecebd4c4a2e18091e2a6aafd23f9b4b81"
  },
  {
    "path": "build/cross-images/x86_64-unknown-linux-musl.dockerfile",
    "chars": 531,
    "preview": "FROM quickwit/cross-base:x86_64-unknown-linux-musl@sha256:5bcc7843aab64f89bf85c464fa2c5a00ecc634a8b1ac88c84a864f60054450"
  },
  {
    "path": "config/quickwit.yaml",
    "chars": 5969,
    "preview": "# ============================ Node Configuration ==============================\n#\n# Website: https://quickwit.io\n# Docs"
  },
  {
    "path": "config/templates/gh-archive.yaml",
    "chars": 881,
    "preview": "version: 0.8\n\ntemplate_id: gh-archive\n\nindex_id_patterns:\n  - gh-archive*\n\ndescription: Index config template for the GH"
  },
  {
    "path": "config/templates/stackoverflow.yaml",
    "chars": 704,
    "preview": "version: 0.8\n\ntemplate_id: stackoverflow\n\nindex_id_patterns:\n  - stackoverflow*\n\ndescription: Index config template for "
  },
  {
    "path": "config/tutorials/fluentbit-logs/index-config.yaml",
    "chars": 309,
    "preview": "version: 0.8\n\nindex_id: fluentbit-logs\n\ndoc_mapping:\n  mode: dynamic\n  field_mappings:\n    - name: timestamp\n      type:"
  },
  {
    "path": "config/tutorials/gh-archive/index-config-for-clickhouse.yaml",
    "chars": 676,
    "preview": "#\n# Index config file for gh-archive dataset.\n#\nversion: 0.8\n\nindex_id: gh-archive\n\ndoc_mapping:\n  store_source: false\n "
  },
  {
    "path": "config/tutorials/gh-archive/index-config.yaml",
    "chars": 798,
    "preview": "#\n# Index config file for gh-archive dataset.\n#\nversion: 0.8\n\nindex_id: gh-archive\n\ndoc_mapping:\n  field_mappings:\n    -"
  },
  {
    "path": "config/tutorials/gh-archive/kafka-source.yaml",
    "chars": 156,
    "preview": "version: 0.8\nsource_id: kafka-source\nsource_type: kafka\nnum_pipelines: 2\nparams:\n  topic: gh-archive\n  client_params:\n  "
  },
  {
    "path": "config/tutorials/gh-archive/kinesis-source.yaml",
    "chars": 94,
    "preview": "version: 0.8\nsource_id: kinesis-source\nsource_type: kinesis\nparams:\n  stream_name: gh-archive\n"
  },
  {
    "path": "config/tutorials/grafana/docker-compose.yml",
    "chars": 2801,
    "preview": "version: \"3.9\"\n\nnetworks:\n  default:\n    name: quickwit-grafana\n    # ipam:\n    #   config:\n    #   - subnet: 172.16.7.0"
  },
  {
    "path": "config/tutorials/hdfs-logs/index-config-partitioned.yaml",
    "chars": 943,
    "preview": "#\n# Index config file for hdfs-logs dataset with partitioning configured.\n#\n\nversion: 0.8\n\nindex_id: hdfs-logs-partition"
  },
  {
    "path": "config/tutorials/hdfs-logs/index-config-retention-policy.yaml",
    "chars": 834,
    "preview": "#\n# Index config file for hdfs-logs dataset with a retention policy configured.\n#\n\nversion: 0.8\n\nindex_id: hdfs-logs-ret"
  },
  {
    "path": "config/tutorials/hdfs-logs/index-config.yaml",
    "chars": 654,
    "preview": "#\n# Index config file for hdfs-logs dataset.\n#\n\nversion: 0.8\n\nindex_id: hdfs-logs\n\ndoc_mapping:\n  field_mappings:\n    - "
  },
  {
    "path": "config/tutorials/hdfs-logs/searcher-1.yaml",
    "chars": 233,
    "preview": "version: 0.8\nnode_id: searcher-1\nlisten_address: 127.0.0.1\nrest:\n  listen_port: 7280\ningest_api:\n  max_queue_memory_usag"
  },
  {
    "path": "config/tutorials/hdfs-logs/searcher-2.yaml",
    "chars": 161,
    "preview": "version: 0.8\nnode_id: searcher-2\nlisten_address: 127.0.0.1\nrest:\n  listen_port: 7290\npeer_seeds:\n  - 127.0.0.1:7280 # se"
  },
  {
    "path": "config/tutorials/hdfs-logs/searcher-3.yaml",
    "chars": 162,
    "preview": "version: 0.8\nnode_id: searcher-3\nlisten_address: 127.0.0.1\nrest:\n  listen_port: 7300\npeer_seeds:\n  - 127.0.0.1:7280 # se"
  },
  {
    "path": "config/tutorials/otel-logs/index-config.yaml",
    "chars": 723,
    "preview": "#\n# Index config file for receiving logs in OpenTelemetry format.\n# Link: https://github.com/open-telemetry/opentelemetr"
  },
  {
    "path": "config/tutorials/otel-logs/kafka-source.yaml",
    "chars": 168,
    "preview": "version: 0.8\nsource_id: kafka-source\nsource_type: kafka\ninput_format: otlp_logs_proto\nparams:\n  topic: otlp_logs\n  clien"
  },
  {
    "path": "config/tutorials/otel-logs/otel-values.yaml",
    "chars": 312,
    "preview": "mode: \"daemonset\"\npresets:\n  logsCollection:\n    enabled: true\n  kubernetesAttributes:\n    enabled: true\nconfig:\n  expor"
  },
  {
    "path": "config/tutorials/otel-traces/index-config.yaml",
    "chars": 1867,
    "preview": "#\n# Index config file for receiving logs in OpenTelemetry format.\n# Link: https://github.com/open-telemetry/opentelemetr"
  },
  {
    "path": "config/tutorials/otel-traces/kafka-source.yaml",
    "chars": 171,
    "preview": "version: 0.8\nsource_id: kafka-source\nsource_type: kafka\ninput_format: otlp_traces_proto\nparams:\n  topic: otlp_spans\n  cl"
  },
  {
    "path": "config/tutorials/stackoverflow/index-config.yaml",
    "chars": 591,
    "preview": "#\n# Index config file for stackoverflow dataset.\n#\nversion: 0.8\n\nindex_id: stackoverflow\n\ndoc_mapping:\n  field_mappings:"
  },
  {
    "path": "config/tutorials/stackoverflow/pulsar-source.yaml",
    "chars": 148,
    "preview": "version: 0.8\nsource_id: pulsar-source\nsource_type: pulsar\nparams:\n  topics:\n    - quickwit/pulsar/stackoverflow\n  addres"
  },
  {
    "path": "config/tutorials/stackoverflow/send_messages_to_pulsar.py",
    "chars": 378,
    "preview": "import json\nimport pulsar\n\nclient = pulsar.Client('pulsar://localhost:6650')\nproducer = client.create_producer('stackove"
  },
  {
    "path": "config/tutorials/vector-otel-logs/vector.toml",
    "chars": 1387,
    "preview": "[sources.generate_syslog]\ntype = \"demo_logs\"\nformat = \"syslog\"\ncount = 100000\ninterval = 0.001\n\n[transforms.remap_syslog"
  },
  {
    "path": "config/tutorials/wikipedia/index-config.yaml",
    "chars": 520,
    "preview": "#\n# Index config file for wikipedia dataset.\n#\n\nversion: 0.8\n\nindex_id: wikipedia\n\ndoc_mapping:\n  field_mappings:\n    - "
  },
  {
    "path": "config/tutorials/wikipedia/multilang-index-config.yaml",
    "chars": 603,
    "preview": "#\n# Index config file for multilang wikipedia datasets.\n#\n\nversion: 0.8\n\nindex_id: multilang-wikipedia\n\ndoc_mapping:\n  t"
  },
  {
    "path": "distribution/docker/ubuntu/Dockerfile",
    "chars": 978,
    "preview": "FROM ubuntu:noble@sha256:66460d557b25769b102175144d538d88219c077c678a49af4afca6fbfc1b5252 AS builder\n\nRUN apt-get update"
  },
  {
    "path": "distribution/ecs/.gitignore",
    "chars": 67,
    "preview": ".terraform\nterraform.tfstate*\n.terraform.tfstate*\nterraform.tfvars\n"
  },
  {
    "path": "distribution/ecs/README.md",
    "chars": 5054,
    "preview": "# ECS deployment for quickwit\n\n## Run Quickwit in your infrastructure\n\nCreate a Quickwit module using:\n\n```terraform\nmod"
  },
  {
    "path": "distribution/ecs/example/.terraform.lock.hcl",
    "chars": 2509,
    "preview": "# This file is maintained automatically by \"terraform init\".\n# Manual edits may be lost in future updates.\n\nprovider \"re"
  },
  {
    "path": "distribution/ecs/example/bastion.tf",
    "chars": 1664,
    "preview": "variable \"bastion_public_key\" {\n  description = \"The public key used to connect to the bastion host. If empty, no bastio"
  },
  {
    "path": "distribution/ecs/example/image.tf",
    "chars": 1268,
    "preview": "variable \"dockerhub_pull_through_creds_secret_arn\" {\n  description = \"If left empty, image is pulled directly from Docke"
  },
  {
    "path": "distribution/ecs/example/kafka.tf",
    "chars": 1858,
    "preview": "# Example configuration for injecting SSL keys for securing a Kafka connection\n# You can then create a secured Kafka sou"
  },
  {
    "path": "distribution/ecs/example/terraform.tf",
    "chars": 2615,
    "preview": "terraform {\n  backend \"local\" {}\n  required_providers {\n    aws = {\n      source  = \"hashicorp/aws\"\n      version = \"~> "
  },
  {
    "path": "distribution/ecs/example/vpc.tf",
    "chars": 358,
    "preview": "module \"vpc\" {\n  source  = \"terraform-aws-modules/vpc/aws\"\n  version = \"5.5.3\"\n\n  name = \"quickwit-ecs\"\n  cidr = \"10.0.0"
  },
  {
    "path": "distribution/ecs/quickwit/cluster.tf",
    "chars": 561,
    "preview": "module \"ecs_cluster\" {\n  source  = \"terraform-aws-modules/ecs/aws//modules/cluster\"\n  version = \"5.9.3\"\n\n  cluster_name "
  },
  {
    "path": "distribution/ecs/quickwit/configs.tf",
    "chars": 1334,
    "preview": "locals {\n  quickwit_peer_list = [\n    \"${aws_service_discovery_service.metastore.name}.${aws_service_discovery_private_d"
  },
  {
    "path": "distribution/ecs/quickwit/iam.tf",
    "chars": 1448,
    "preview": "data \"aws_iam_policy_document\" \"quickwit_task_permission\" {\n  # Reference: https://quickwit.io/docs/guides/aws-setup#ama"
  },
  {
    "path": "distribution/ecs/quickwit/outputs.tf",
    "chars": 832,
    "preview": "output \"indexer_service_name\" {\n  value = \"${aws_service_discovery_service.indexer.name}.${aws_service_discovery_private"
  },
  {
    "path": "distribution/ecs/quickwit/quickwit-control-plane.tf",
    "chars": 1614,
    "preview": "module \"quickwit_control_plane\" {\n  source                         = \"./service\"\n  service_name                   = \"con"
  },
  {
    "path": "distribution/ecs/quickwit/quickwit-indexer.tf",
    "chars": 1798,
    "preview": "module \"quickwit_indexer\" {\n  source                         = \"./service\"\n  service_name                   = \"indexer\"\n"
  },
  {
    "path": "distribution/ecs/quickwit/quickwit-janitor.tf",
    "chars": 1578,
    "preview": "module \"quickwit_janitor\" {\n  source                         = \"./service\"\n  service_name                   = \"janitor\"\n"
  },
  {
    "path": "distribution/ecs/quickwit/quickwit-metastore.tf",
    "chars": 1590,
    "preview": "module \"quickwit_metastore\" {\n  source                         = \"./service\"\n  service_name                   = \"metasto"
  },
  {
    "path": "distribution/ecs/quickwit/quickwit-searcher.tf",
    "chars": 1584,
    "preview": "module \"quickwit_searcher\" {\n  source                         = \"./service\"\n  service_name                   = \"searcher"
  },
  {
    "path": "distribution/ecs/quickwit/rds.tf",
    "chars": 2396,
    "preview": "resource \"random_password\" \"quickwit_db\" {\n  count   = local.use_external_rds ? 0 : 1\n  length  = 64\n  special = false\n}"
  },
  {
    "path": "distribution/ecs/quickwit/s3.tf",
    "chars": 263,
    "preview": "data \"aws_caller_identity\" \"current\" {}\n\nresource \"aws_s3_bucket\" \"index\" {\n  count         = var.quickwit_index_s3_pref"
  },
  {
    "path": "distribution/ecs/quickwit/service/config.tf",
    "chars": 1011,
    "preview": "locals {\n  quickwit_data_dir = \"/quickwit/qwdata\"\n\n  quickwit_common_environment = [\n    {\n      name  = \"QW_ENABLED_SER"
  },
  {
    "path": "distribution/ecs/quickwit/service/ecs.tf",
    "chars": 3024,
    "preview": "module \"quickwit_service\" {\n  source  = \"terraform-aws-modules/ecs/aws//modules/service\"\n  version = \"5.9.3\"\n\n  name    "
  },
  {
    "path": "distribution/ecs/quickwit/service/variables.tf",
    "chars": 1414,
    "preview": "variable \"service_name\" {\n  description = \"One of indexer, metastore, searcher, control_plane, janitor\"\n}\n\nvariable \"ser"
  },
  {
    "path": "distribution/ecs/quickwit/variables.tf",
    "chars": 4006,
    "preview": "## REQUIRED VARIABLES\n\nvariable \"vpc_id\" {\n  description = \"VPC ID of the cluster\"\n}\n\nvariable \"subnet_ids\" {\n  descript"
  },
  {
    "path": "distribution/kubernetes/README.md",
    "chars": 264,
    "preview": "# Quickwit on Kubernetes\n\nTo deploy Quickwit on Kubernetes, use the official Quickwit Helm chart available at [helm.quic"
  },
  {
    "path": "docker-compose.yml",
    "chars": 7816,
    "preview": "# By default, this docker compose script maps all services to localhost only.\n# If you need to make services available o"
  },
  {
    "path": "docs/assets/sqs-file-source.tf",
    "chars": 2992,
    "preview": "terraform {\n  required_version = \"1.7.5\"\n  required_providers {\n    aws = {\n      source  = \"hashicorp/aws\"\n      versio"
  },
  {
    "path": "docs/configuration/_category_.yaml",
    "chars": 51,
    "preview": "label: 'Configuration'\nposition: 4\ncollapsed: true\n"
  },
  {
    "path": "docs/configuration/index-config.md",
    "chars": 33749,
    "preview": "---\ntitle: Index configuration\nsidebar_position: 3\ntoc_max_heading_level: 4\n---\n\nThis page describes how to configure an"
  },
  {
    "path": "docs/configuration/index.md",
    "chars": 105,
    "preview": "---\ntitle: Configuration Reference\n---\n\nimport DocCardList from '@theme/DocCardList';\n\n<DocCardList />\n\n\n"
  },
  {
    "path": "docs/configuration/lambda-config.md",
    "chars": 7018,
    "preview": "---\ntitle: Lambda configuration\nsidebar_position: 6\n---\n\nQuickwit supports offloading leaf search operations to AWS Lamb"
  },
  {
    "path": "docs/configuration/metastore-config.md",
    "chars": 3830,
    "preview": "---\ntitle: Metastore configuration\nsidebar_position: 4\n---\n\nQuickwit needs a place to store meta-information about its i"
  },
  {
    "path": "docs/configuration/node-config.md",
    "chars": 14701,
    "preview": "---\ntitle: Node configuration\nsidebar_position: 1\n---\n\nThe node configuration allows you to customize and optimize the s"
  },
  {
    "path": "docs/configuration/ports-config.md",
    "chars": 1527,
    "preview": "---\ntitle: Ports configuration\nsidebar_position: 6\n---\n\nWhen starting a quickwit search server, one important parameter "
  },
  {
    "path": "docs/configuration/source-config.md",
    "chars": 14612,
    "preview": "---\ntitle: Source configuration\nsidebar_position: 5\n---\n\nQuickwit can insert data into an index from one or multiple sou"
  },
  {
    "path": "docs/configuration/storage-config.md",
    "chars": 5527,
    "preview": "---\ntitle: Storage configuration\nsidebar_position: 2\n---\n\n## Supported Storage Providers\n\nQuickwit currently supports fo"
  },
  {
    "path": "docs/configuration/template-config.md",
    "chars": 3592,
    "preview": "---\ntitle: Index template configuration\nsidebar_position: 7\ntoc_max_heading_level: 4\n---\n\nThis page describes how to con"
  },
  {
    "path": "docs/deployment/_category_.yaml",
    "chars": 48,
    "preview": "label: 'Deployment'\nposition: 7\ncollapsed: true\n"
  },
  {
    "path": "docs/deployment/cluster-sizing.md",
    "chars": 5099,
    "preview": "---\ntitle: Cluster sizing\nsidebar_position: 3\n---\n\nIn this guide, we discuss how to size your Quickwit cluster and nodes"
  },
  {
    "path": "docs/deployment/deployment-modes.md",
    "chars": 2763,
    "preview": "---\ntitle: Deployment modes\nsidebar_position: 1\n---\n\nAs an application, Quickwit is built out of multiple services and i"
  },
  {
    "path": "docs/deployment/kubernetes/_category_.yaml",
    "chars": 48,
    "preview": "label: 'Kubernetes'\nposition: 2\ncollapsed: true\n"
  },
  {
    "path": "docs/deployment/kubernetes/gke.md",
    "chars": 3061,
    "preview": "---\ntitle: Install Quickwit on Google GKE\nsidebar_label: Google GKE\nsidebar_position: 2\n---\n\nThis guide will help you se"
  },
  {
    "path": "docs/deployment/kubernetes/glasskube.md",
    "chars": 2467,
    "preview": "---\ntitle: Install Quickwit with Glasskube\nsidebar_label: Glasskube\nsidebar_position: 3\n---\n\n[Glasskube](https://glassku"
  },
  {
    "path": "docs/deployment/kubernetes/helm.md",
    "chars": 3384,
    "preview": "---\ntitle: Install Quickwit with Helm\nsidebar_label: Helm\nsidebar_position: 1\n---\n\n[Helm](https://helm.sh) is a package "
  },
  {
    "path": "docs/distributed-tracing/_category_.yaml",
    "chars": 57,
    "preview": "label: 'Distributed tracing'\nposition: 6\ncollapsed: true\n"
  },
  {
    "path": "docs/distributed-tracing/otel-service.md",
    "chars": 4725,
    "preview": "---\ntitle: OTEL service\nsidebar_position: 5\n---\n\nQuickwit natively supports the [OpenTelemetry Protocol (OTLP)](https://"
  },
  {
    "path": "docs/distributed-tracing/overview.md",
    "chars": 1667,
    "preview": "---\ntitle: Distributed Tracing with Quickwit\nsidebar_label: Overview\nsidebar_position: 1\n---\n\nDistributed Tracing is a p"
  },
  {
    "path": "docs/distributed-tracing/plug-quickwit-to-jaeger.md",
    "chars": 3408,
    "preview": "---\ntitle: Plug Quickwit to Jaeger\ndescription: A simple tutorial to use Jaeger with Quickwit backend.\nicon_url: /img/tu"
  },
  {
    "path": "docs/distributed-tracing/send-traces/_category_.yaml",
    "chars": 53,
    "preview": "label: 'Sending traces'\nposition: 3\ncollapsed: false\n"
  },
  {
    "path": "docs/distributed-tracing/send-traces/using-otel-collector.md",
    "chars": 3498,
    "preview": "---\ntitle: Using OTEL Collector\ndescription: Using OTEL Collector\ntags: [otel, collector, traces]\nsidebar_position: 1\n--"
  },
  {
    "path": "docs/distributed-tracing/send-traces/using-otel-sdk-python.md",
    "chars": 7945,
    "preview": "---\ntitle: Using OTEL SDK - Python\ndescription: A simple tutorial to send traces to Quickwit from a Python Flask app.\nic"
  },
  {
    "path": "docs/get-started/_category_.yaml",
    "chars": 50,
    "preview": "label: 'Get started'\nposition: 2\ncollapsed: false\n"
  },
  {
    "path": "docs/get-started/installation.md",
    "chars": 6358,
    "preview": "---\ntitle: Installation\nsidebar_position: 2\n---\n\nimport Tabs from '@theme/Tabs';\nimport TabItem from '@theme/TabItem';\ni"
  },
  {
    "path": "docs/get-started/query-language-intro.md",
    "chars": 3499,
    "preview": "---\ntitle: Introduction to Quickwit's query language\nsidebar_position: 3\n---\n\nQuickwit allows you to search on your inde"
  },
  {
    "path": "docs/get-started/quickstart.md",
    "chars": 8500,
    "preview": "---\ntitle: Quickstart\nsidebar_position: 1\n---\n\nimport Tabs from '@theme/Tabs';\nimport TabItem from '@theme/TabItem';\n\nIn"
  },
  {
    "path": "docs/get-started/tutorials/_category_.yaml",
    "chars": 48,
    "preview": "label: 'Tutorials'\nposition: 2\ncollapsed: false\n"
  },
  {
    "path": "docs/get-started/tutorials/prometheus-metrics.md",
    "chars": 3197,
    "preview": "---\ntitle: Metrics with Grafana and Prometheus\ndescription: A simple tutorial to display Quickwit metrics with Grafana.\n"
  },
  {
    "path": "docs/get-started/tutorials/trace-analytics-with-grafana.md",
    "chars": 3915,
    "preview": "---\ntitle: Logs and Traces with Grafana\ndescription: A simple tutorial to use Grafana with Quickwit's datasource plugin."
  },
  {
    "path": "docs/get-started/tutorials/tutorial-hdfs-logs-distributed-search-aws-s3.md",
    "chars": 9367,
    "preview": "---\ntitle: Distributed search on AWS S3\ndescription: Index log entries on AWS S3 using an EC2 instance and launch a dist"
  },
  {
    "path": "docs/get-started/tutorials/tutorial-hdfs-logs.md",
    "chars": 8067,
    "preview": "---\ntitle: Index a logging dataset locally\ndescription: Index log entries on a local machine.\ntags: [self-hosted, setup]"
  },
  {
    "path": "docs/get-started/tutorials/tutorial-jaeger.md",
    "chars": 2627,
    "preview": "---\ntitle: Traces with Jaeger\nsidebar_position: 2\n---\n\nIn this quick start guide, we will set up a Quickwit instance and"
  },
  {
    "path": "docs/guides/_category_.yaml",
    "chars": 44,
    "preview": "label: 'Guides'\nposition: 8\ncollapsed: true\n"
  },
  {
    "path": "docs/guides/aws-setup.md",
    "chars": 4486,
    "preview": "---\ntitle: AWS cluster setup\nsidebar_position: 3\n---\n\nSetting up a Quickwit cluster on AWS requires the configuration of"
  },
  {
    "path": "docs/guides/schemaless.md",
    "chars": 8300,
    "preview": "---\ntitle: Schemaless\nsidebar_position: 1\n---\n\n# Strict schema or schemaless?\n\nQuickwit lets you place the cursor on how"
  },
  {
    "path": "docs/guides/storage-setup/_category_.yaml",
    "chars": 51,
    "preview": "label: 'Storage Setup'\nposition: 2\ncollapsed: true\n"
  },
  {
    "path": "docs/guides/storage-setup/aws-s3.md",
    "chars": 809,
    "preview": "---\ntitle: AWS S3\nsidebar_position: 1\n---\n\nIn this guide, you will learn how to configure a Quickwit [storage](../../con"
  },
  {
    "path": "docs/ingest-data/_category_.yaml",
    "chars": 49,
    "preview": "label: 'Ingest data'\nposition: 4\ncollapsed: true\n"
  },
  {
    "path": "docs/ingest-data/index.md",
    "chars": 523,
    "preview": "---\ntitle: Ingest data from multiple sources\n---\n\nimport DocCardList from '@theme/DocCardList';\n\n<DocCardList />\n\nIt is "
  },
  {
    "path": "docs/ingest-data/ingest-api.md",
    "chars": 3889,
    "preview": "---\ntitle: Ingest API\ndescription: A short tutorial describing how to send data in Quickwit using the ingest API\ntags: ["
  },
  {
    "path": "docs/ingest-data/ingest-local-file.md",
    "chars": 2684,
    "preview": "---\ntitle: Local file\ndescription: A short tutorial describing how to index a local file with the Quickiwt CLI \ntags: [l"
  },
  {
    "path": "docs/ingest-data/kafka.md",
    "chars": 7395,
    "preview": "---\ntitle: Kafka\ndescription: A short tutorial describing how to set up Quickwit to ingest data from Kafka in a few minu"
  },
  {
    "path": "docs/ingest-data/kinesis.md",
    "chars": 7088,
    "preview": "---\ntitle: Kinesis\ndescription: A short tutorial describing how to set up Quickwit to ingest data from Kinesis in a few "
  },
  {
    "path": "docs/ingest-data/pulsar.md",
    "chars": 6927,
    "preview": "---\ntitle: Pulsar\ndescription: A short tutorial describing how to set up Quickwit to ingest data from Pulsar in a few mi"
  },
  {
    "path": "docs/ingest-data/sqs-files.md",
    "chars": 7130,
    "preview": "---\ntitle: S3 with SQS notifications\ndescription: A short tutorial describing how to set up Quickwit to ingest data from"
  },
  {
    "path": "docs/internals/backward-compatibility.md",
    "chars": 5651,
    "preview": "# Backward compatibility in Quickwit.\n\nIf you are reading this, chances are you want to make a change to one of the reso"
  },
  {
    "path": "docs/internals/date-time.md",
    "chars": 534,
    "preview": "# Datetime format\n\nQuickwit's DateTime is a wrapper around Tantivy's provided DateTime type which is internally represen"
  },
  {
    "path": "docs/internals/ingest-v2.md",
    "chars": 2494,
    "preview": "# Ingest V2\n\nIngest V2 is the latest ingestion API that is designed to be more efficient and scalable for thousands of i"
  },
  {
    "path": "docs/internals/scroll.md",
    "chars": 3751,
    "preview": "# Scroll API\n\nThe scroll API has been implemented to offer compatibility with ElasticSearch.\nThe API and the implementat"
  },
  {
    "path": "docs/internals/searcher-split-cache.md",
    "chars": 977,
    "preview": "\n# Searcher split cache\n\nQuickwit includes a split cache. It can be useful for specific workloads:\n- to improve performa"
  },
  {
    "path": "docs/internals/sorting.md",
    "chars": 2868,
    "preview": "# Sorting\n\nQuickwit can sort results based on fastfield values or score. This document discuss where and how\n it happens"
  },
  {
    "path": "docs/internals/split-format.md",
    "chars": 1470,
    "preview": "# Split format\n\nQuickwit's index are divided into small independent immutable piece of index called split.\n\nFor convenie"
  },
  {
    "path": "docs/internals/template-index.md",
    "chars": 1401,
    "preview": "# Index template API\n\nIndex templates are a way to create indexes automatically with some given configuration when Quick"
  },
  {
    "path": "docs/log-management/_category_.yaml",
    "chars": 52,
    "preview": "label: 'Log management'\nposition: 5\ncollapsed: true\n"
  },
  {
    "path": "docs/log-management/otel-service.md",
    "chars": 4239,
    "preview": "---\ntitle: OTEL service\nsidebar_position: 4\n---\n\nQuickwit natively supports the [OpenTelemetry Protocol (OTLP)](https://"
  },
  {
    "path": "docs/log-management/overview.md",
    "chars": 908,
    "preview": "---\ntitle: Log management with Quickwit\nsidebar_label: Overview\nsidebar_position: 1\n---\n\nQuickwit is built from the grou"
  },
  {
    "path": "docs/log-management/send-logs/_category_.yaml",
    "chars": 51,
    "preview": "label: 'Sending logs'\nposition: 2\ncollapsed: false\n"
  },
  {
    "path": "docs/log-management/send-logs/send-docker-logs.md",
    "chars": 4084,
    "preview": "---\ntitle: Send docker logs into Quickwit\nsidebar_label: Docker logs into Quickwit\ndescription: Send docker logs into Qu"
  },
  {
    "path": "docs/log-management/send-logs/using-fluentbit.md",
    "chars": 2819,
    "preview": "---\ntitle: Send logs using Fluentbit\nsidebar_label: Using Fluentbit\ndescription: A simple tutorial to send logs from Flu"
  },
  {
    "path": "docs/log-management/send-logs/using-otel-collector-with-helm.md",
    "chars": 9320,
    "preview": "---\ntitle: Send K8s logs using OTEL collector\nsidebar_label: Using OTEL with Helm\ndescription: Send K8s logs with OTEL c"
  },
  {
    "path": "docs/log-management/send-logs/using-otel-collector.md",
    "chars": 3316,
    "preview": "---\ntitle: Send logs from OTEL Collector\nsidebar_label: Using OTEL collector\ndescription: Using OTEL Collector\ntags: [ot"
  },
  {
    "path": "docs/log-management/send-logs/using-vector.md",
    "chars": 5329,
    "preview": "---\ntitle: Send logs from Vector\nsidebar_label: Using Vector\ndescription: A simple tutorial to send logs from Vector to "
  },
  {
    "path": "docs/log-management/supported-agents.md",
    "chars": 3418,
    "preview": "---\ntitle: Supported agents\nsidebar_position: 3\n---\n\nQuickwit is compatible with the following agents:\n\n## OpenTelemetry"
  },
  {
    "path": "docs/operating/_category_.yaml",
    "chars": 56,
    "preview": "label: 'Operating Quickwit'\nposition: 7\ncollapsed: true\n"
  },
  {
    "path": "docs/operating/aws-costs.md",
    "chars": 2441,
    "preview": "---\ntitle: AWS Cost Optimization\nsidebar_position: 3\n---\n\nQuickwit has been tested on Amazon S3. This page sums up what "
  },
  {
    "path": "docs/operating/data-directory.md",
    "chars": 7424,
    "preview": "---\ntitle: Data directory\nsidebar_position: 1\n---\n\nQuickwit operates on a local directory to store temporary files. By d"
  },
  {
    "path": "docs/operating/monitoring.md",
    "chars": 1048,
    "preview": "---\ntitle: Monitoring with Grafana\nsidebar_position: 2\n---\n\nYou can monitor your Quickwit cluster with Grafana.\nFollow t"
  },
  {
    "path": "docs/operating/upgrades.md",
    "chars": 2902,
    "preview": "---\ntitle: Version upgrade\nsidebar_position: 4\n---\n\n## Migration from 0.6.x to 0.7.0\n\nThe format of the index and intern"
  },
  {
    "path": "docs/overview/_category_.yaml",
    "chars": 50,
    "preview": "label: 'Introduction'\nposition: 1\ncollapsed: true\n"
  },
  {
    "path": "docs/overview/architecture.md",
    "chars": 7484,
    "preview": "---\ntitle: Architecture\nsidebar_position: 2\n---\n\nQuickwit distributed search engine relies on 4 major services and one m"
  },
  {
    "path": "docs/overview/concepts/_category_.yaml",
    "chars": 55,
    "preview": "label: 'Advanced concepts'\nposition: 3\ncollapsed: true\n"
  },
  {
    "path": "docs/overview/concepts/deletes.md",
    "chars": 2221,
    "preview": "---\ntitle: Deletes\nsidebar_position: 3\n---\n\nQuickwit supports deletes thanks to the [delete API](../../reference/rest-ap"
  },
  {
    "path": "docs/overview/concepts/indexing.md",
    "chars": 3580,
    "preview": "---\ntitle: Indexing\nsidebar_position: 1\n---\n\n## Supported data formats\n\nQuickwit ingests JSON records and refers to them"
  },
  {
    "path": "docs/overview/concepts/querying.md",
    "chars": 7189,
    "preview": "---\ntitle: Querying\nsidebar_position: 2\n---\n\nA search query received by a searcher will be executed using a map-reduce a"
  },
  {
    "path": "docs/overview/index.md",
    "chars": 1197,
    "preview": "---\ntitle: Quickwit documentation\nslug: /\nsidebar_position: 1\n---\n\nimport CallToAction from '@theme/CallToAction';\n\nQuic"
  },
  {
    "path": "docs/overview/introduction.md",
    "chars": 3181,
    "preview": "---\ntitle: What is Quickwit?\nsidebar_position: 1\n---\n\nQuickwit is the first engine to execute complex search and analyti"
  },
  {
    "path": "docs/reference/_category_.yaml",
    "chars": 48,
    "preview": "label: 'Reference'\nposition: 11\ncollapsed: true\n"
  },
  {
    "path": "docs/reference/aggregation.md",
    "chars": 31279,
    "preview": "---\ntitle: Aggregations API\nsidebar_position: 30\n---\n\nAn aggregation summarizes your data as statistics on buckets or me"
  },
  {
    "path": "docs/reference/cli.md",
    "chars": 26762,
    "preview": "---\ntitle: Command-line options\nsidebar_position: 50\n---\n\nQuickwit command line tool lets you start a Quickwit server an"
  },
  {
    "path": "docs/reference/es_compatible_api.md",
    "chars": 36184,
    "preview": "---\ntitle: Elasticsearch compatible API\nsidebar_position: 20\n---\n\n\nIn order to facilitate migrations and integrations wi"
  },
  {
    "path": "docs/reference/metrics.md",
    "chars": 5102,
    "preview": "---\ntitle: Metrics\nsidebar_position: 70\n---\n\nQuickwit exposes key metrics in the [Prometheus](https://prometheus.io/) fo"
  },
  {
    "path": "docs/reference/query-language.md",
    "chars": 9395,
    "preview": "---\ntitle: Query Language Reference\nsidebar_position: 40\n---\n\n## Pseudo-grammar\n\n```\nquery = '(' query ')'\n      | query"
  },
  {
    "path": "docs/reference/rest-api.md",
    "chars": 36330,
    "preview": "---\ntitle: REST API\nsidebar_position: 10\n---\n\n## API version\n\nAll the API endpoints start with the `api/v1/` prefix. `v1"
  },
  {
    "path": "docs/reference/updating-mapper.md",
    "chars": 7352,
    "preview": "# Updating the doc mapping of an index\n\nQuickwit allows updating the mapping it uses to add more fields to an existing i"
  },
  {
    "path": "docs/telemetry.md",
    "chars": 1455,
    "preview": "---\ntitle: Telemetry\nsidebar_position: 12\n---\n\nQuickwit, Inc. collects anonymous data regarding general usage to help us"
  },
  {
    "path": "install.sh",
    "chars": 14983,
    "preview": "#!/bin/bash\n\n# installer.sh\n#\n# This is just a little script that can be downloaded from the internet to\n# install Quick"
  },
  {
    "path": "monitoring/grafana/README.md",
    "chars": 141,
    "preview": "# Grafana dashboards for monitoring Quickwit\n\nThe list of featured dashboards:\n- [x] Metastore\n- [x] Indexers\n- [x] Sear"
  },
  {
    "path": "monitoring/grafana/dashboards/indexers.json",
    "chars": 31242,
    "preview": "{\n  \"annotations\": {\n    \"list\": [\n      {\n        \"builtIn\": 1,\n        \"datasource\": {\n          \"type\": \"grafana\",\n  "
  },
  {
    "path": "monitoring/grafana/dashboards/ingesters.json",
    "chars": 16350,
    "preview": "{\n  \"annotations\": {\n    \"list\": [\n      {\n        \"builtIn\": 1,\n        \"datasource\": {\n          \"type\": \"grafana\",\n  "
  },
  {
    "path": "monitoring/grafana/dashboards/metastore.json",
    "chars": 9850,
    "preview": "{\n  \"annotations\": {\n    \"list\": [\n      {\n        \"builtIn\": 1,\n        \"datasource\": {\n          \"type\": \"grafana\",\n  "
  },
  {
    "path": "monitoring/grafana/dashboards/searchers.json",
    "chars": 22117,
    "preview": "{\n  \"annotations\": {\n    \"list\": [\n      {\n        \"builtIn\": 1,\n        \"datasource\": {\n          \"type\": \"grafana\",\n  "
  },
  {
    "path": "monitoring/grafana/provisioning/dashboards/default.yaml",
    "chars": 181,
    "preview": "apiVersion: 1\n\nproviders:\n  - name: Default\n    folder: Quickwit\n    allowUiUpdates: true\n    options:\n      path: /var/"
  },
  {
    "path": "monitoring/grafana/provisioning/datasources/default.yaml",
    "chars": 446,
    "preview": "apiVersion: 1\n\ndatasources:\n  - id: 1\n    name: Prometheus\n    type: prometheus\n    typeName: Prometheus\n    access: pro"
  },
  {
    "path": "monitoring/otel-collector-config.yaml",
    "chars": 807,
    "preview": "receivers:\n  jaeger:\n    protocols:\n      grpc:\n      thrift_binary:\n      thrift_compact:\n      thrift_http:\n\n  otlp:\n "
  },
  {
    "path": "monitoring/prometheus.yaml",
    "chars": 193,
    "preview": "global:\n  scrape_interval: 1s\n  scrape_timeout: 1s\n\nscrape_configs:\n  - job_name: quickwit\n    metrics_path: /metrics\n  "
  },
  {
    "path": "quickwit/.cargo/config.toml",
    "chars": 48,
    "preview": "[build]\nrustflags = [\"--cfg\", \"tokio_unstable\"]\n"
  },
  {
    "path": "quickwit/.cargo-dev/config.toml",
    "chars": 531,
    "preview": "# This configuration makes it possible to use mold\n# as the linker for rustc.\n#\n# I recommended it for development as it"
  },
  {
    "path": "quickwit/.config/nextest.toml",
    "chars": 274,
    "preview": "[profile.default]\nslow-timeout = \"10s\"\n\n[profile.ci]\n# Print out output for failing tests as soon as they fail, and also"
  }
]

// ... and 1006 more files (download for full content)