feat(storage-opendal)!: make the per-IO-operation timeout configurable by comphead · Pull Request #3263 · apache/iceberg-rust

comphead · 2026-09-22T16:40:51Z

Which issue does this PR close?

Part of opendal FileIO hard-wires TimeoutLayer defaults (10s per-IO) with no way to configure them; large Parquet row groups fail deterministically on S3 #2977.

What changes are included in this PR?

iceberg-storage-opendal wraps every FileIO operator in TimeoutLayer::new(). Its 10s io_timeout bounds each read/write and every method call on a returned reader, writer, lister or deleter, and nothing in the property or builder surface can override it:

https://github.com/apache/iceberg-rust/blob/bb1e4a4/crates/storage/opendal/src/lib.rs#L394

An operation that legitimately needs longer then fails deterministically, not flakily: RetryLayer re-sends the same request, which cannot fit in the budget either, so every attempt dies at the same place and the error surfaces as persistent.

Unexpected (persistent) at read, context: { timeout: 10 } => io operation timeout reached

Add opendal.io-timeout-ms and hand it to TimeoutLayer::with_io_timeout. Only this crate honors it, so the key is namespaced under opendal. and defined here as OPENDAL_IO_TIMEOUT_MS, not in iceberg::io. One property covers every backend rather than one per service. Unset keeps OpenDAL's 10s, exposed as OPENDAL_IO_TIMEOUT_MS_DEFAULT. Zero and non-numeric values are rejected rather than silently ignored, and the error keeps the parse failure as its source, so it says why. OpenDalStorageFactory rejects them at build time. OpenDalResolvingStorage rejects them when it first resolves a scheme, which is also when it parses the backend properties. A serialized storage with a zero timeout fails to deserialize. TimeoutLayer stays inside RetryLayer, so each attempt is still independently bounded.

The property is parsed into a new OpenDalClientConfig, built with #[derive(Properties)]. Every OpenDalStorage variant carries it as a client_config field, and OpenDalStorage::client_config() returns it. Its field is private, so later client settings such as retry can be added without changing the enum again. OpenDalClientConfig::io_timeout() returns the timeout as a Duration. The field itself is a NonZeroU64 in milliseconds, so parsing and deserializing share the zero check.

Breaking (API): every OpenDalStorage variant gains a client_config: OpenDalClientConfig field: Memory, LocalFs, S3, Gcs, Oss, Azdls, and Hf. Memory(Operator) becomes Memory { operator, client_config }, and LocalFs becomes LocalFs { client_config }. Code that builds any variant, or matches one without .., needs updating. Passing OpenDalClientConfig::default() keeps the current behavior.

Breaking (serialized form): this affects code that serializes an OpenDalStorage itself, for example as a dyn Storage through typetag. FileIO::serialize_all is not affected, because it serializes the factory and properties, and neither factory changes. LocalFs and Memory used to serialize as the bare strings "LocalFs" and "Memory", and now serialize as {"LocalFs": {"client_config": {...}}} and {"Memory": {"client_config": {...}}}. Neither version can read the other's form, so a LocalFs or Memory storage serialized by an earlier version must be rebuilt rather than deserialized. In JSON, S3, Gcs, Oss, Azdls, and Hf stay compatible in both directions, because a missing client_config falls back to the default and older versions ignore it as an unknown field. The OpenDalStorage docs now say that its serialized form is not stable across crate versions, as FileIO::serialize_all already says of its own.

#3179 bounds the S3 write request size, which removes the oversized-part case on the write path. This covers the general one, including reads. Scaling the deadline with payload size (option 2 in #2977) is not available: OpenDAL dropped TimeoutLayer::with_speed in apache/opendal#6793.

The 60s timeout for control operations is left alone, as it has not been reported as a problem. The property docs now name it, and that here it covers exists and metadata, while reads, writes, listing and deletes use the new property.

Are these changes tested?

Unit tests:

test_io_timeout_parsing: default when unset, override, 1 and u64::MAX as the smallest and largest accepted values, and rejection of 0, -1, 12.5, abc, the empty string, and u64::MAX + 1. The error names the property, quotes the rejected value, and carries the parse error that says why it was rejected.
test_default_matches_property_defaults: OpenDalClientConfig::default(), which serde uses, matches the #[property] defaults that from_properties uses.
test_default_timeouts_match_opendal: OPENDAL_IO_TIMEOUT_MS_DEFAULT and the 60s control budget named in the docs stay equal to OpenDAL's TimeoutLayer defaults, so an OpenDAL upgrade that changes either fails here.
test_factory_rejects_invalid_io_timeout: OpenDalStorageFactory::build surfaces a parse failure instead of falling back.
test_io_timeout_reaches_timeout_layer: the configured value reaches TimeoutLayer::with_io_timeout. A memory operator behind ConcurrentLimitLayer::new(0) stalls every IO call, and a read with a 45000 ms setting fails with timeout: 45. Paused tokio time, from the dev-only test-util feature, skips the wait and the retry backoff. With a bare TimeoutLayer::new() the test fails with timeout: 10.
test_resolve_propagates_io_timeout: OpenDalResolvingStorage::resolve propagates the property for every enabled scheme, including in a memory-only build.
test_client_config_serde_round_trip: client_config survives a serde round trip, a payload with a zero timeout fails to deserialize, and a payload without client_config falls back to the default.
test_old_unit_variant_forms_are_rejected: the old "LocalFs", "Memory" and {"Memory": null} forms fail to deserialize, which pins the serialized-form break as intended.

AI Disclosure

AI-assisted implementation.

comphead · 2026-09-22T16:46:40Z

@mbutrovich FYI

Copilot

Warning

Copilot couldn't run its full agentic review because it didn't start before the timeout. Make sure your repository has a runner available, or add a copilot-code-review.yml file specifying one with the runs-on attribute. See the docs for more details.

Copilot review overview

Review effort: Lite
Findings: 3 · 1

Open (4)

The wildcard arm (_ => default_io_timeout_ms()) plus #[allow(unreachable_patterns)] makes this… · New
Hardcoding 10_000 as the OpenDAL TimeoutLayer default is brittle: if OpenDAL changes its… · New
For values like the empty string, the error renders as Invalid client.io-timeout-ms: , ..., which… · New
The tests duplicate the default value (10_000). Using default_io_timeout_ms() for the expected… · New

What changed in this PR

Adds a new storage configuration property to make OpenDAL’s per-IO-operation timeout configurable, and wires it through the OpenDAL storage factory/resolver into TimeoutLayer.

Changes:

Introduce client.io-timeout-ms (CLIENT_IO_TIMEOUT_MS) as a shared storage property in iceberg.
Parse/validate the timeout in iceberg-storage-opendal and propagate it through factory + resolving storage variants.
Apply the configured timeout to TimeoutLayer::with_io_timeout, plus add unit tests for parsing and propagation.

File	Description
crates/storage/opendal/src/utils.rs	Adds default + parsing/validation for `client.io-timeout-ms` and unit tests.
crates/storage/opendal/src/resolving.rs	Parses timeout once per build and stores it in each resolved `OpenDalStorage` variant; adds propagation test.
crates/storage/opendal/src/lib.rs	Extends `OpenDalStorage` variants to carry `io_timeout_ms`, parses it in `StorageFactory::build`, and applies it to `TimeoutLayer`.
crates/storage/opendal/public-api.txt	Updates exported API surface to reflect enum variant shape/fields changes.
crates/iceberg/src/io/storage/config/mod.rs	Introduces the `CLIENT_IO_TIMEOUT_MS` property constant with docs.
crates/iceberg/public-api.txt	Public API snapshot updated to include `CLIENT_IO_TIMEOUT_MS`.

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

xanderbailey

Thanks for working on this! I do think having a more generic OpenDal config might work better here and we can parse it with the new properties macro. It'll make this more expandable in the future I think. WDYT?

mbutrovich

Thanks @comphead for picking this up, Comet will be glad to have it. My comments are about how the new setting fits the repo's config conventions: how it gets parsed and how it's carried on the OpenDalStorage variants.

`iceberg-storage-opendal` wraps every FileIO operator in `TimeoutLayer::new()`, whose 10s `io_timeout` bounds each `read`/`write` and each method call on a returned reader or writer. Nothing in the property or builder surface can override it, so an operation that legitimately needs longer fails deterministically: the `RetryLayer` above re-sends the same request, which cannot fit in the budget either. Add `client.io-timeout-ms`, parsed into an `OpenDalClientConfig` built with `#[derive(Properties)]` and handed to `TimeoutLayer::with_io_timeout`. The config's fields are private, so later client settings such as retry are additive rather than breaking. The default is unchanged. BREAKING CHANGE: `OpenDalStorage` variants carry a `client` field, and `OpenDalStorage::Memory` is now a struct variant.

Quote the rejected value in the parse error, so an empty input shows as `value: ""`. `TimeoutLayer` exposes no getters, so a new test compares its `Debug` output to pin `DEFAULT_IO_TIMEOUT_MS` to OpenDAL's default. The parsing test now uses the constant instead of repeating the literal. Add a serde round-trip test for the `client` field, including a payload that omits it. Drop the `DEFAULT` associated const, which only fed a fallback arm that cannot run. Update the upstream `test_writer_close_returns_stored_size` for the struct variant, and reuse `StorageConfig::with_prop` and `empty_resolving_storage` in the tests.

…meout-ms Only `iceberg-storage-opendal` honors the key, so namespace it under `opendal.` and define it as `OPENDAL_IO_TIMEOUT_MS` next to `OpenDalClientConfig`, rather than in `iceberg::io`. This matches how `ADLS_SAS_TOKEN` and `GCS_ALLOW_ANONYMOUS` sit next to the configs that parse them. With the key moved, the `iceberg` crate needs no change.

comphead · 2026-09-24T16:45:59Z

Depends on #3263

comphead · 2026-09-25T14:51:56Z

@kevinjqliu cc

appreciate if you can take a look, in Comet we got file scan tasks restarted because of uncontrollable timeout which makes the entire execution time longer. the PR is to expose timeout value to external users

Copilot

Warning

Copilot couldn't run its full agentic review because it didn't start before the timeout. Make sure your repository has a runner available, or add a copilot-code-review.yml file specifying one with the runs-on attribute. See the docs for more details.

Copilot review overview

Review effort: Lite
Findings: 1 · 2

Open (3)

This test relies on Debug output for semantic equivalence, which is brittle: Debug formatting… · New
The doc comment hard-codes the default as 10000, but the actual default is controlled by… · New
The relative ordering of TimeoutLayer vs RetryLayer is behaviorally significant (per-attempt… · New

Resolved since last review (4)

For values like the empty string, the error renders as Invalid client.io-timeout-ms: , ..., which…
Hardcoding 10_000 as the OpenDAL TimeoutLayer default is brittle: if OpenDAL changes its…
The wildcard arm (_ => default_io_timeout_ms()) plus #[allow(unreachable_patterns)] makes this…
The tests duplicate the default value (10_000). Using default_io_timeout_ms() for the expected…

comphead · 2026-10-01T16:01:10Z

+        // `TimeoutLayer` has no getters, so compare through `Debug`. An OpenDAL upgrade that
+        // changes its default fails here instead of silently diverging from it.
+        assert_eq!(
+            format!("{:?}", TimeoutLayer::new()),
+            format!(
+                "{:?}",
+                TimeoutLayer::new().with_io_timeout(Duration::from_millis(DEFAULT_IO_TIMEOUT_MS))
+            ),
+        );


Kept it, since TimeoutLayer has no getters and both sides go through the same derived Debug, so a format change alone cannot make them differ. The assert_ne! from 5e9641c catches a Debug that stops printing io_timeout.

comphead · 2026-10-01T16:01:12Z


+/// Deadline in milliseconds for one IO operation, and for every method call on a returned
+/// reader, writer, lister or deleter. Honored by every [`OpenDalStorage`] backend, where it
+/// defaults to 10000 to match OpenDAL's `TimeoutLayer`.


Fixed. The doc now links to the new OPENDAL_IO_TIMEOUT_MS_DEFAULT instead of repeating the number.

`client` reads like an HTTP client handle. Rename the field on every `OpenDalStorage` variant, and the `OpenDalStorage::client()` accessor, to `client_config` to match `OpenDalClientConfig`. `opendal_config` would be ambiguous next to the backend `config` field, which holds an OpenDAL config too. `test_default_io_timeout_matches_opendal` compares `Debug` output. Both sides go through the same derived impl, so a format change cannot make them differ. A `Debug` that stopped printing `io_timeout` would make the check pass vacuously, so also assert that a different `io_timeout` produces a different string.

`OpenDalClientConfig::io_timeout_ms()` returned `&NonZeroU64`, because the `Properties` derive only returns primitives by value. Replace the generated getter with `io_timeout()`, which returns a `Duration`, and keep the millisecond field private. Expose the default as `OPENDAL_IO_TIMEOUT_MS_DEFAULT`, following the `*_DEFAULT` consts in `iceberg`, so the key's doc links to it instead of repeating the number. Keep the `ParseIntError` as the source of a rejected value, as `parse_pool_property` does, so the message says why it failed. Document that the serialized form of `OpenDalStorage` is not stable across crate versions, as `FileIO::serialize_all` already does for its own. Test that the configured timeout reaches `TimeoutLayer`. A memory operator behind `ConcurrentLimitLayer::new(0)` stalls every IO call, and paused tokio time skips the wait and the retry backoff. Check propagation through `OpenDalResolvingStorage` for every enabled scheme, not only S3.

comphead · 2026-10-01T16:01:26Z

@laskoviymishka The description now lists every variant that gained client_config and calls out the serialized-format break separately from the API break.

@xanderbailey Agreed. FileIO::serialize_all already says its form is not stable across crate versions, so I added the same note to OpenDalStorage instead of adding back-compat.

…erive Build `OpenDalClientConfig::default()` from `from_properties` with no properties, so each default is declared once in `#[property]` and serde and `from_properties` cannot disagree as settings are added. Say in the `parse_io_timeout_ms` doc that it exists to quote the value and name the unit, and that `NonZeroU64` is what rejects zero. Fold the valid-value asserts in the parsing test into one loop.

comphead · 2026-10-01T16:17:09Z

Thanks @laskoviymishka and @xanderbailey for the review, PTAL

kevinjqliu · 2026-10-02T17:59:19Z

taking a look! sorry github ui is glitching for me

laskoviymishka

Thanks for the quick turnaround. The round-1 blocker is resolved now: the serialized-form break is called out separately, the new client_config fields are listed, and the timeout getter / parse error / new tests cover the gaps from last round.

One thing I’d still fix before merge: the title says datafusion, but nothing in the diff touches DataFusion. I’d drop that scope and use feat(storage-opendal)!: … instead.

The rest is minor and inline: the .expect() in Default is a future panic if a field ever has no default =, the control-op budget note could mention the 60s value, and there are a couple of small test nits.

Fix the title and I’m good with this.

laskoviymishka · 2026-10-02T18:59:54Z

+/// defaults to [`OPENDAL_IO_TIMEOUT_MS_DEFAULT`].
+///
+/// Each retry attempt is bounded separately, so it is a per-attempt budget, not a total one.
+/// Control operations such as `stat` and `rename` are bounded by a separate, fixed budget.


While we're documenting this, I'd give the "separate, fixed budget" line a concrete number — it's OpenDAL's 60s control-op default, and it also governs delete and the lister/deleter open, not just stat/rename. Otherwise someone who sets io-timeout-ms=5000 to bound all their I/O gets surprised when metadata fetches and snapshot-expiry deletes still hang for up to a minute.

Added the 60s, pinned to OpenDAL's default by test_default_timeouts_match_opendal, and the doc now names exists and metadata as the calls that keep it. Deletes and listing are not control operations in OpenDAL 0.58, which wraps deleters and listers in the IO timeout, and a stalled delete with a 45000 ms setting fails with timeout: 45.

laskoviymishka · 2026-10-02T18:59:54Z

+impl Default for OpenDalClientConfig {
+    fn default() -> Self {
+        // Reuse the `#[property]` defaults, so serde and `from_properties` cannot disagree.
+        Self::from_properties(&HashMap::new()).expect("every client setting has a default")


I'd build this default directly (Self { io_timeout_ms: DEFAULT_IO_TIMEOUT_MS }) rather than route through from_properties().expect(). It's safe today, but the moment someone adds a #[property] field without a default =, this becomes a production panic on the deserialization path — serde calls default() for every absent client_config, so a stored payload missing that field would panic instead of erroring. If you want to keep the single-source guarantee, a #[test] asserting default() == from_properties(&empty) turns the drift into a CI failure instead.

Agreed, and the exposure is wider than absent payloads, since the container #[serde(default)] makes serde call default() on every client_config it deserializes. Reverted to the struct literal and added test_default_matches_property_defaults, which compares default() with from_properties on an empty map.

laskoviymishka · 2026-10-02T18:59:54Z

+
+    #[cfg(feature = "opendal-s3")]
+    #[test]
+    fn test_client_config_serde_round_trip() {


The "Breaking (serialized form)" section covers the wire break well and I'm happy with the docs-only path we settled on last round — not reopening that. One cheap addition while you're in here: a test asserting an old bare-string "LocalFs" / {"Memory": null} payload now is_err() would pin the break as intended behavior rather than an accident, sitting right next to this round-trip test. Not blocking.

Added test_old_unit_variant_forms_are_rejected next to the round trip. It checks that "LocalFs", "Memory" and {"Memory": null} all fail to deserialize.

laskoviymishka · 2026-10-02T18:59:54Z

+            .unwrap_err()
+            .to_string();
+        assert!(err.contains("io operation timeout reached"), "{err}");
+        assert!(err.contains("timeout: 45"), "{err}");


"timeout: 45" also matches "timeout: 450", so this passes if the layer ever reports 450s — "timeout: 45s" with the unit pins it to the value you actually mean.

OpenDAL renders the budget as plain seconds (timeout.as_secs_f64().to_string()), so the error reads context: { timeout: 45 } and "timeout: 45s" would never match. The assertion now matches { timeout: 45 }, whose closing brace rules out 450.

comphead · 2026-10-02T19:45:47Z

Thanks @laskoviymishka for the review, addressing

`Default` delegated to `from_properties` with no properties and called `expect`. A later setting without a `#[property]` default would make it panic, and because of the container-level `#[serde(default)]`, serde calls `default()` on every `client_config` it deserializes. Build the struct directly, and keep the two defaults equal with `test_default_matches_property_defaults`. Name OpenDAL's 60-second control-operation budget in the `OPENDAL_IO_TIMEOUT_MS` doc, along with the calls it covers here, `exists` and `metadata`. `test_default_timeouts_match_opendal` now pins both defaults that the doc states. Pin the serialized-form break with a test that rejects the old `"LocalFs"`, `"Memory"` and `{"Memory": null}` forms. Match the stall test's error on `{ timeout: 45 }`, so a 450-second budget cannot pass.

comphead · 2026-10-02T20:28:38Z

@laskoviymishka Thanks. The title now drops the datafusion scope, and 189914c addresses the inline points.

laskoviymishka · 2026-10-02T20:34:05Z

Will wait for some time before merging (looks like @kevinjqliu still looking)

…vate `OpenDalStorage::client_config()`, `OpenDalClientConfig::io_timeout()` and `OPENDAL_IO_TIMEOUT_MS_DEFAULT` have no callers outside the crate. Keep them out of the public API so they can be exposed later without a breaking change. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Fold the `u64` default into the `NonZeroU64` const, drop `test_default_matches_property_defaults` (one field, one shared const), shorten docs and comments that restated the code, and keep the original `op` binding in the `Memory` arm of `create_operator`. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

Name OpenDAL's `io_timeout` and `timeout` settings so it is clear the property bounds each IO call per retry attempt and leaves control operations such as `stat` at 60 seconds. Align the `OpenDalStorage` serialization note with the wording on `FileIO::serialize_all`. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

…timeout Every `OpenDalStorageFactory::build` arm could fall back to the default `OpenDalClientConfig` without any test failing. Build each enabled backend with a 45000 ms timeout and read it back from the serialized storage. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>

kevinjqliu

LGTM! Thanks for adding this (and for your patience waiting for reviews).

I only have a few nit comments. Trying out a new workflow where i add some of the nits and comments as commits on top of the PR. Hope you don't mind, and please lmk if you dont like this flow, I can add regular comments to the PR.

I added a few changes:

25612d5 makes client_config(), io_timeout() and OPENDAL_IO_TIMEOUT_MS_DEFAULT crate-private, since nothing in the repo uses them. Happy to revert and expose them again if Comet or other downstream users need them.
3b169cd trims redundant consts, comments and a test to keep the diff tight.
38af8ab clarifies io_timeout vs timeout in the docs, and aligns the serialization note with FileIO::serialize_all.
b56cbb4 adds a test that OpenDalStorageFactory propagates the timeout. Nothing covered it before.

The description still lists those three items as public, so it'll need a small update.

PTAL! And feel free to revert any you disagree with.

comphead · 2026-10-04T16:06:16Z

Thanks @kevinjqliu appreciate if we can merge the PR

kevinjqliu · 2026-10-04T16:06:40Z

@comphead if you’re happy with the changes, lmk and I can press merge!

kevinjqliu · 2026-10-04T16:07:34Z

Thanks for the pr! I’m excited to see more opendal integration. And thanks everyone for the reviews! 🚢

Bump iceberg-rust to af1da4c (apache/iceberg-rust#3263), which adds the `opendal.io-timeout-ms` FileIO property, and set it from the new `spark.comet.iceberg.ioTimeout` config (default 30s) for native Iceberg scans and writes. Forward `opendal.*` keys to the native FileIO. The bump also needs two API updates: `FileWrite::close` now returns `FileMetadata`, and `UnboundPartitionField` is built with its builder. Closes apache#6124.

Resolve conflicts with the configurable OpenDAL IO timeout (apache#3263): storage variants carry both the credential provider and the client config.

Copilot AI lite review requested due to automatic review settings September 22, 2026 16:40

comphead force-pushed the io-timeout-config branch from 43cc854 to b1751f9 Compare September 22, 2026 16:45

Copilot AI reviewed Sep 22, 2026

View reviewed changes

Comment thread crates/storage/opendal/src/lib.rs Outdated

Comment thread crates/storage/opendal/src/utils.rs Outdated

Comment thread crates/storage/opendal/src/utils.rs Outdated

Comment thread crates/storage/opendal/src/utils.rs Outdated

Copilot started reviewing on behalf of comphead September 22, 2026 17:59 View session

xanderbailey reviewed Sep 22, 2026

View reviewed changes

Comment thread crates/storage/opendal/src/lib.rs Outdated

xanderbailey reviewed Sep 22, 2026

View reviewed changes

mbutrovich reviewed Sep 22, 2026

View reviewed changes

Comment thread crates/iceberg/src/io/storage/config/mod.rs Outdated

Comment thread crates/storage/opendal/src/lib.rs Outdated

comphead mentioned this pull request Sep 22, 2026

Iceberg scan fails with a hard-wired 10s OpenDAL io_timeout that cannot be configured apache/datafusion-comet#6124

Closed

comphead force-pushed the io-timeout-config branch 2 times, most recently from 0c255ee to 1ef4025 Compare September 23, 2026 03:43

ovoievodin added 2 commits September 23, 2026 17:10

comphead force-pushed the io-timeout-config branch from 1ef4025 to a075964 Compare September 24, 2026 00:34

xanderbailey reviewed Sep 24, 2026

View reviewed changes

Comment thread crates/iceberg/src/io/storage/config/mod.rs Outdated

Merge branch 'main' into io-timeout-config

3a3df73

comphead requested review from mbutrovich and xanderbailey September 24, 2026 21:48

comphead changed the title ~~feat(storage-opendal)!: make the per-IO-operation timeout configurable~~ feat(storage-opendal, datafusion)!: make the per-IO-operation timeout configurable Sep 24, 2026

kevinjqliu requested a balanced review from Copilot September 28, 2026 17:51

Copilot AI reviewed Sep 28, 2026

View reviewed changes

Copilot started reviewing on behalf of kevinjqliu September 28, 2026 18:22 View session

comphead added the datafusion label Sep 28, 2026

xanderbailey reviewed Sep 28, 2026

View reviewed changes

Comment thread crates/storage/opendal/src/lib.rs Outdated

comphead and others added 3 commits September 28, 2026 17:16

Merge branch 'main' into io-timeout-config

fff1bba

Merge branch 'main' into io-timeout-config

f5e118a

kevinjqliu requested review from kevinjqliu and removed request for xanderbailey October 2, 2026 17:58

laskoviymishka approved these changes Oct 2, 2026

View reviewed changes

comphead changed the title ~~feat(storage-opendal, datafusion)!: make the per-IO-operation timeout configurable~~ feat(storage-opendal)!: make the per-IO-operation timeout configurable Oct 2, 2026

laskoviymishka added this pull request to the merge queue Oct 2, 2026

laskoviymishka removed this pull request from the merge queue due to a manual request Oct 2, 2026

kevinjqliu and others added 4 commits October 4, 2026 07:53

kevinjqliu approved these changes Oct 4, 2026

View reviewed changes

kevinjqliu mentioned this pull request Oct 4, 2026

docs: add agent guidance to reduce verbosity #3337

Merged

kevinjqliu added this pull request to the merge queue Oct 4, 2026

Merged via the queue into apache:main with commit af1da4c Oct 4, 2026
24 checks passed

comphead mentioned this pull request Oct 5, 2026

fix: make the native Iceberg per-I/O timeout configurable apache/datafusion-comet#6649

Merged

Conversation

comphead commented Sep 22, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Which issue does this PR close?

What changes are included in this PR?

Are these changes tested?

AI Disclosure

Uh oh!

comphead commented Sep 22, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Copilot review overview

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

xanderbailey left a comment

Choose a reason for hiding this comment

Uh oh!

mbutrovich left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

comphead commented Sep 24, 2026

Uh oh!

comphead commented Sep 25, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Copilot review overview

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

comphead commented Oct 1, 2026

Uh oh!

comphead commented Oct 1, 2026

Uh oh!

kevinjqliu commented Oct 2, 2026

Uh oh!

laskoviymishka left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

comphead commented Oct 2, 2026

Uh oh!

comphead commented Oct 2, 2026

Uh oh!

laskoviymishka commented Oct 2, 2026

Uh oh!

kevinjqliu left a comment

Choose a reason for hiding this comment

Uh oh!

comphead commented Oct 4, 2026

Uh oh!

kevinjqliu commented Oct 4, 2026

Uh oh!

comphead commented Sep 22, 2026 •

edited

Loading