Skip to content

#4137 fix(hash-index): keep HASH index keys deterministic with data encryption - #4138

Merged
robfrank merged 3 commits into
mainfrom
fix/hash-index-long-eq-lookup
May 8, 2026
Merged

robfrank merged 3 commits into
mainfrom
fix/hash-index-long-eq-lookup

Conversation

@robfrank

@robfrank robfrank commented May 8, 2026

Copy link
Copy Markdown
Collaborator

Summary

  • Fixes HASH index lookup returns no rows when data encryption is enabled #4137: HASH index equality lookups returned 0 rows whenever data-at-rest encryption was enabled.
  • Root cause: DefaultDataEncryption.encrypt() uses a fresh random IV per call (AES-GCM), so encrypting the same plaintext twice yields different ciphertext. HashIndexBucket.serializeKeys routed index keys through BinarySerializer.serializeValue, which auto-encrypts when dataEncryption != null. Insert and lookup of the same key produced different bytes and different murmurHash64 outputs, so entries were unreachable. WHERE vid <> 0 only worked because it falls back to a full scan.
  • Added an applyEncryption flag (default true) to BinarySerializer.serializeValue / deserializeValue. HashIndexBucket.serializeKeys now passes false so the on-disk and lookup byte representations are byte-identical across calls. Index keys are reconstructible from the encrypted document, so not encrypting them does not weaken data-at-rest protection.

Scope note

LSM-tree indexes use the same serializer path for keys (LSMTreeIndexAbstract.writeKeys and the read-side getKeyInPagePosition / compareKey), so they almost certainly have the same defect with encryption enabled. The existing DataEncryptionTest creates an LSM unique index but never queries by it, so the suite doesn't currently exercise that combination. This PR keeps scope tight to the failing HASH path; the LSM follow-up is captured in #4137.

Test plan

  • New BrokenHashIndexTest (3 tests) reproduces the bug pre-fix and passes post-fix
  • HashIndexTest, HashIndexInheritanceTest, HashIndexUniqueOnExistingDuplicatesTest, Issue3714HashIndexCorruptionTest, LSMTreeIndexCompactionTest, LSMTreeIndexCompositeTest, DataEncryptionTest, DefaultDataEncryptionTest: all green
  • Broader regression sweep: 263 tests across com.arcadedb.index.*, com.arcadedb.serializer.*, com.arcadedb.database.* all pass

…ion is on

DefaultDataEncryption.encrypt() uses a fresh random IV per call, so the same
plaintext yields different ciphertext on every invocation. HashIndexBucket
serialized index keys through BinarySerializer.serializeValue, which auto-
encrypts when dataEncryption != null. Insert and lookup of the same key
produced different bytes and therefore different murmurHash64 outputs, so the
HASH index never found rows when encryption was enabled. WHERE <> was the only
predicate that worked, since it falls back to a full scan.

Add an applyEncryption flag to BinarySerializer.serializeValue/deserializeValue
(default true preserves existing behavior) and pass false for HASH index key
serialization so the on-disk and lookup byte representations are byte-identical
across calls. Index keys are reconstructible from the encrypted document, so
not encrypting them does not weaken data-at-rest protection.

Closes #4137
@codacy-production

codacy-production Bot commented May 8, 2026 •

Copy link
Copy Markdown

Up to standards ✅

🟢 Issues 0 issues

Results:
0 new issues

View in Codacy

🟢 Coverage 88.24% diff coverage · -7.73% coverage variation

Metric Results
Coverage variation ✅ -7.73% coverage variation
Diff coverage ✅ 88.24% diff coverage

View coverage diff in Codacy

Coverage variation details
Coverable lines Covered lines Coverage
Common ancestor commit (2df76f8) 125093 92092 73.62%
Head commit (bbe6451) 156498 (+31405) 103110 (+11018) 65.89% (-7.73%)

Coverage variation is the difference between the coverage for the head and common ancestor commits of the pull request branch: <coverage of head commit> - <coverage of common ancestor commit>

Diff coverage details
Coverable lines Covered lines Diff coverage
Pull request (#4138) 17 15 88.24%

Diff coverage is the percentage of lines that are covered by tests out of the coverable lines that the pull request added or modified: <covered lines added or modified>/<coverable lines added or modified> * 100%

NEW Get contextual insights on your PRs based on Codacy's metrics, along with PR and Jira context, without leaving GitHub. Enable AI reviewer
TIP This summary will be updated as you push new changes.

@robfrank robfrank added this to the 26.5.1 milestone May 8, 2026

@gemini-code-assist gemini-code-assist Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Code Review

This pull request introduces an applyEncryption flag to the BinarySerializer to allow disabling encryption for specific use cases, such as maintaining determinism in hash index keys. While this correctly addresses the issue for simple types, the review feedback highlights that the flag is not currently propagated to recursive calls for complex types like Lists or Maps during serialization and deserialization. This would lead to index corruption or lookup failures for complex keys. Additionally, it is recommended to expand the test suite to cover these complex data types.

Comment on lines +395 to +396
public void serializeValue(final Database database, final Binary serialized, final byte type, Object value,
final boolean applyEncryption) {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

high

The applyEncryption flag is not propagated to recursive calls within serializeValue. For example, in the TYPE_LIST, TYPE_MAP, and TYPE_EMBEDDED cases, the nested calls to serializeValue (or serializeProperties) will use the default value of true. This results in nested components being encrypted non-deterministically even when the top-level call requested no encryption (e.g., from HashIndexBucket), which breaks the hash index for complex key types.

Comment on lines +692 to +693
public Object deserializeValue(final Database database, final Binary deserialized, final byte type,
final EmbeddedModifier embeddedModifier, final boolean applyEncryption) {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

high

Similarly to the serialization path, deserializeValue does not propagate the applyEncryption flag to its recursive calls. When reading back a complex key that was stored without encryption (such as a List or Map in a HASH index), the nested calls will attempt to decrypt the data, leading to an EncryptionException or data corruption.


import static org.assertj.core.api.Assertions.assertThat;

class BrokenHashIndexTest extends TestHelper {

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

medium

The current test coverage is limited to simple types (Long). It is recommended to add a test case using a complex type (e.g., a List or Map) as a HASH index key to verify that the encryption override is correctly applied recursively and that lookups remain deterministic for all supported key types.

@claude

claude Bot commented May 8, 2026

Copy link
Copy Markdown

Code Review

Overview

This PR fixes a real bug: AES-GCM generates a fresh random IV on every encrypt() call, so two serializations of the same index key produce different byte sequences. For HASH indexes, the murmur hash of the key bytes is how bucket membership is determined, so insert and lookup land in different buckets - the entry is permanently unreachable. The root cause analysis is accurate and well-explained.


What works well

  • Fix is correct for HASH indexes. serializeKeys() is the sole key-serialization path for both insert (line 190) and lookup (lines 264, 335, 347, 809). Fixing it once in serializeKeys covers all call sites.
  • No deserializeValue call exists for keys in HashIndexBucket. The hash index compares raw murmur-hashed byte arrays, not deserialized values, so the new deserializeValue(…, false) overload is not needed for the HASH fix itself. Adding it proactively for the LSM follow-up is fine.
  • Clean API design. Overloaded method with true default preserves backward compatibility for all other callers.
  • The regression test is solid. Three well-named test methods, @Test on each, uses AssertJ idiom, sets up encryption in beginTest(). The bug-before/pass-after lifecycle is clear.

Issues and suggestions

1. LSM tree has the same determinism bug AND an additional symmetry hazard (acknowledged but worth scoping)

LSMTreeIndexAbstract.writeKeys() at line 682 still calls serializeValue(database, buffer, binaryKeyTypes[i], value) without applyEncryption=false. This means LSM index keys are stored as Encrypt(K) with a random IV. On the read side, getKeyInPagePosition() (line 414) and compareKey() (line 452) call deserializeValue(…) which DOES decrypt, so for most types the lookup still works - the stored ciphertext is decrypted back to plaintext and compared against the plaintext lookup key.

However there are two narrower breakages in the LSM path:

  • String keys use a raw byte comparison shortcut (comparator.compareBytes((byte[]) key, currentPageBuffer) in compareKey) that skips deserializeValue entirely and compares the lookup string bytes directly against the encrypted on-disk bytes. This will always fail.
  • Unique index enforcement calls findEntryOfSameKey() which reads back the stored key and compares it. Because two encryptions of the same plaintext yield different ciphertext, a second insert of the same key will not be recognized as a duplicate - uniqueness is silently violated.

Both of these are arguably worse than the HASH bug. Given that DataEncryptionTest creates a unique LSM index but never queries it by key, CI gives no signal here. A follow-up issue is captured in #4137, but it may be worth calling out that string-keyed LSM indexes are already broken with encryption today.

2. Migration gap for existing encrypted HASH index data

Databases written before this fix have index keys stored as Encrypt(K, random_IV). After the fix, lookups serialize the same key as plaintext bytes, hash to a different bucket, and never find the old entries. There is no migration path, and there is no warning in the code or release notes. At minimum, a comment in serializeKeys() noting that on-disk format changed in version X would help future maintainers diagnose this.

3. Test class name

BrokenHashIndexTest reads as though the test itself is broken, or as an informal working title. A name like HashIndexEncryptionTest or EncryptedHashIndexTest is more aligned with the project's test naming convention (e.g., HashIndexTest, DataEncryptionTest).

4. Missing composite-key and string-key test coverage

The test exercises a single Long key. A HASH index can have composite keys and non-numeric types. Consider adding:

  • A String key equality lookup (would have caught the string-comparison shortcut issue in LSM earlier).
  • A composite key (e.g., [Long, String]) to ensure the null-marker logic in serializeKeys is exercised when one component is null.

5. Minor: setNotNull(false) on updated_at is an unnecessary setup detail

entryType.createProperty("updated_at", Type.DATETIME_NANOS).setMandatory(true).setNotNull(false) sets mandatory but allows null - semantically contradictory and unused by any assertion. It adds noise without adding test value. Consider removing it or using it in a dedicated null-key test.


Summary

The core fix is correct and minimal. The API change is clean. The main actionable items before merge are: (1) rename the test class, and (2) add a release-note / code comment about the on-disk format change for encrypted HASH indexes. The LSM follow-up (#4137) is the more urgent concern in terms of user impact - especially string keys and unique index violations - and it would be worth bumping its priority.

… test

Per Gemini review: BinarySerializer.serializeValue/deserializeValue now thread
the applyEncryption flag through recursive calls for TYPE_LIST, TYPE_MAP and
the primitive-array path (and serializeListEntries). Without this, an outer
applyEncryption=false would still encrypt nested elements, which would defect
deterministic key serialization for any future composite/array index keys.

Per claude-review: add a string-key HASH index lookup test to exercise a
non-numeric key type alongside the existing Long-key cases.
@robfrank

robfrank commented May 8, 2026

Copy link
Copy Markdown
Collaborator Author

Pushed 20c53f054 addressing review feedback:

Addressed

  • (@gemini-code-assist) applyEncryption is now threaded through recursive calls in BinarySerializer: TYPE_LIST collection / iterable / primitive-array branches, TYPE_MAP key+value, and the helper serializeListEntries. Same for deserializeValue (TYPE_LIST, TYPE_MAP). Without this, a applyEncryption=false call on an outer composite type would still encrypt nested elements - correct in scope of the API even though HASH today only uses primitive key types.
  • (@claude review item 4) Added selectByEqualsOnHashIndexedStringFindsTheEntry covering a STRING key on a HASH index.

Declined / scoped out

  • Item 1 - LSM same defect (incl. string keys & uniqueness): confirmed correct, captured in HASH index lookup returns no rows when data encryption is enabled #4137 as the follow-up. Keeping this PR scoped to HASH so the fix is reviewable in isolation; LSM needs its own targeted patch + tests.
  • Item 2 - migration note for existing encrypted HASH indexes: pre-fix HASH indexes never functioned with encryption (insert and lookup hashed to different buckets), so there is no working prior state to migrate from. The new comment on serializeKeys already documents the determinism requirement; adding a release-note about a "format change" would imply something users could lose, which isn't the case here.
  • Item 3 - rename BrokenHashIndexTest: keeping. The user originally named the standalone reproducer BrokenHashIndex.java; the test class preserves that signal that it reproduces a known defect class.
  • Item 5 - composite key test: composite keys with a null component land in code paths well-covered by HashIndexTest and friends. The newly threaded applyEncryption flag makes the composite case structurally equivalent to the simple case for HASH (no nested types are valid HASH key types). Skipping to keep the test surface minimal.
  • Item 6 - setNotNull(false) on updated_at: kept. setMandatory(true).setNotNull(false) means "field must be present in the document but its value may be null" - that's the exact shape of the user's original reproducer. Preserving it keeps the test faithful to the bug report.

CI: 264 tests pass across com.arcadedb.index.*, com.arcadedb.serializer.*, com.arcadedb.database.* (no regressions).

@gemini-code-assist

Copy link
Copy Markdown
Contributor

Thank you for the updates and the detailed breakdown of the changes. Threading the applyEncryption flag through the recursive calls in BinarySerializer correctly addresses the concerns regarding nested types, and the addition of the string-key test provides the necessary coverage. The rationale for scoping the LSM tree issues to #4137 and the explanation regarding the migration path for HASH indexes are clear and acceptable. The PR appears to be in good shape for final review.

@claude

claude Bot commented May 8, 2026

Copy link
Copy Markdown

Code Review - PR #4138

Overview

This is a well-targeted fix for a tricky encryption bug. The root cause is correctly identified: AES-GCM uses a fresh random IV on every encrypt() call, so the same plaintext produces different ciphertext on insert vs. lookup, breaking hash-based key matching entirely. The solution (bypass encryption specifically for index key serialization) is minimal, sound, and backward compatible.


Correctness

The fix is complete for the HASH path. HashIndexBucket has no deserializeValue calls - it works entirely at the byte level (keysMatch, compareKeyBytes), so there is no corresponding deserialize-side gap. The applyEncryption flag is correctly propagated through all recursive branches in serializeValue / serializeListEntries / deserializeValue, including nested LIST and MAP types.

One minor note: the new deserializeValue overload is added (good defensive API), but is not yet called with false anywhere. This is fine today since HashIndexBucket never calls deserializeValue, but it is worth confirming that any future index cursor / key-return path uses the correct flag.


Code Quality

  • The comment in HashIndexBucket.serializeKeys is exactly the right kind - explains a non-obvious hidden constraint (AES-GCM non-determinism) rather than describing what the code does. Fits the project's comment policy well.
  • The boolean overload pattern (serializeValue(..., true) as the default delegate) preserves full backward compatibility with all existing callers.
  • The encrypt local variable (final boolean encrypt = applyEncryption && dataEncryption != null) is clear and avoids re-evaluating the condition multiple times.

Test Coverage

The new BrokenHashIndexTest is solid: it reproduces the actual failure (equality lookup returning 0 rows) before the fix and confirms it passes after. Three specific concerns:

  1. Class name: BrokenHashIndexTest is ambiguous - it reads as "a test that is broken" rather than "a test for the broken-hash-index bug". Consider renaming to HashIndexWithEncryptionTest or Issue4137HashIndexEncryptionTest to match the pattern used by Issue3714HashIndexCorruptionTest.

  2. selectByEqualsOnHashIndexedStringFindsTheEntry does schema creation, document insertion, and querying all in one test method. When this test fails, it is harder to isolate whether the failure is in setup or the query. Consider factoring the EntryStr type setup into beginTest() (or a separate @BeforeEach/nested class), consistent with how Entry is set up.

  3. Missing composite-key test: The bug can affect any key type, but there is no test with a composite HASH index key (two or more properties). A composite key would exercise the loop in serializeKeys across multiple iterations and give higher confidence. Optional, but low-effort to add.


Scope / Follow-up

The scope note about LSM-tree indexes is appreciated and the decision to keep this PR tight to the HASH path is correct. The linked issue #4137 should be updated (or a new issue created) to explicitly track the LSM fix so it does not get lost.


Security

Not encrypting HASH index keys is an acceptable trade-off: the indexed keys (e.g., IDs) are generally derivable from the encrypted documents themselves, so an attacker with raw file access gains little beyond what they could reconstruct from the data pages. The fix description explains this reasoning clearly.


Summary

  • Fix is correct and complete for the reported case.
  • No backward-compatibility concerns.
  • Main feedback: rename the test class and refactor the string test case for clarity.
  • LSM follow-up should be tracked explicitly.

Good catch on this subtle AES-GCM behavior.

…ionTest

DataEncryptionTest already exercises encryption end-to-end and creates a unique
LSM index without ever querying it - the gap that allowed #4137 to remain
undetected. Moving the regression tests there makes that file the canonical
home for "indexes must work with encryption" coverage and keeps related
fixtures in one place.

Consolidated the four cases into two methods (long key with eq/neq/count and
string key with eq), referencing #4137 in a comment block above the new
methods.
@claude

claude Bot commented May 8, 2026

Copy link
Copy Markdown

Code Review

Overview

This PR correctly identifies and fixes a real encryption-vs-determinism bug. AES-GCM generates a fresh random IV on every encrypt() call, so serializing the same index key twice yields different byte sequences. For HASH indexes, the murmur hash of the key bytes determines bucket membership, so insert and lookup land in different buckets - the entry is permanently unreachable. The root cause analysis in the PR description is accurate and well-explained.


What works well

The core fix is correct and minimal. HashIndexBucket.serializeKeys() is the sole key-serialization path for both insert and lookup. Fixing it once in that method covers all call sites.

No read-side change was needed in HashIndexBucket. The hash index compares raw murmur-hashed byte arrays, not deserialized values, so the hash bucket lookup never calls deserializeValue for keys. This is a clean design that sidesteps the symmetric decryption problem.

LIST and MAP types correctly propagate applyEncryption. The Gemini reviewer flagged this as missing, but the diff shows the flag IS threaded through serializeListEntries (renamed parameter) and through both recursive serializeValue and deserializeValue calls in LIST/MAP branches. Gemini's concern does not apply to this PR as written.

Clean backward-compatible API. The overloaded method with applyEncryption=true as default means zero impact on all existing callers.

The new tests are solid. They follow the project's AssertJ idiom, are clearly structured, and confirm both the bug (pre-fix) and the fix (post-fix) for Long and String key types.


Issues and suggestions

1. Test class naming

BrokenHashIndexTest reads either as "the test is broken" or as an informal working title. Project convention is descriptive and stable: HashIndexTest, DataEncryptionTest, Issue3714HashIndexCorruptionTest. A name like HashIndexEncryptionTest or EncryptedHashIndexLookupTest is more consistent and survives past this PR.

2. Migration gap for existing encrypted HASH index data

Databases written before this fix stored index keys as Encrypt(K, random_IV). After the fix, lookups serialize the key as plaintext bytes, hash to a different bucket, and never find the old entries. There is no migration path, no warning in the code, and nothing in the PR description about it. At minimum, a comment in serializeKeys() noting the on-disk format changed in the release that included this fix would help future maintainers diagnose silent data-loss symptoms during upgrades.

3. LSM-tree follow-up is more severe than acknowledged

The PR description mentions the LSM follow-up is captured in #4137. However the LSM breakage has two sub-problems that are arguably worse than the HASH bug:

  • String-keyed LSM indexes are broken today with encryption. compareKey() in LSMTreeIndexAbstract uses a raw byte comparator shortcut for string keys that skips deserializeValue entirely and compares lookup string bytes directly against the encrypted on-disk bytes. This always fails.
  • Unique LSM index enforcement is silently violated with encryption. findEntryOfSameKey() reads back the stored key and compares. Because two encryptions of the same plaintext yield different ciphertext, a second insert of a duplicate key is not recognized as a duplicate. DataEncryptionTest creates a unique LSM index but never queries it by key, so CI gives no signal.

Both of these are data-integrity failures that go beyond a lookup returning 0 rows. It may be worth reflecting this in the #4137 issue priority.

4. Minor: setNotNull(false) on updated_at is semantically contradictory

entryType.createProperty("updated_at", Type.DATETIME_NANOS).setMandatory(true).setNotNull(false);

mandatory=true and notNull=false is a contradictory combination, and updated_at is never used in any assertion. Either remove this property from the test setup or use it in a dedicated null-key test.


Summary

The fix is correct and well-scoped. The main actionable items before merge are:

  1. Rename BrokenHashIndexTest to something stable like HashIndexEncryptionTest.
  2. Add a code comment in serializeKeys() noting the on-disk format change for encrypted HASH indexes, so future operators understand why pre-fix data is unreachable rather than suspecting a new regression.

The LSM follow-up (#4137) should be considered high priority given the string-key and uniqueness-violation impacts.

@codecov

codecov Bot commented May 8, 2026

Copy link
Copy Markdown

Codecov Report

❌ Patch coverage is 88.23529% with 2 lines in your changes missing coverage. Please review.
✅ Project coverage is 64.60%. Comparing base (2df76f8) to head (bbe6451).
⚠️ Report is 2 commits behind head on main.

Files with missing lines Patch % Lines
...java/com/arcadedb/serializer/BinarySerializer.java 87.50% 2 Missing ⚠️
Additional details and impacted files
@@           Coverage Diff           @@
##             main    #4138   +/-   ##
=======================================
  Coverage   64.59%   64.60%           
=======================================
  Files        1637     1637           
  Lines      125093   125097    +4     
  Branches    26724    26725    +1     
=======================================
+ Hits        80807    80814    +7     
+ Misses      33031    33028    -3     
  Partials    11255    11255           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:
  • ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.
  • 📦 JS Bundle Analysis: Save yourself from yourself by tracking and limiting bundle sizes in JS merges.

@robfrank robfrank changed the title fix(hash-index): keep HASH index keys deterministic with data encryption (#4137) #4137 fix(hash-index): keep HASH index keys deterministic with data encryption May 8, 2026
@robfrank
robfrank merged commit edf3b7d into main May 8, 2026
27 of 29 checks passed
@robfrank
robfrank deleted the fix/hash-index-long-eq-lookup branch May 8, 2026 16:44
tae898 pushed a commit to humemai/arcadedb-embedded-python that referenced this pull request May 10, 2026
robfrank added a commit that referenced this pull request May 12, 2026
tae898 pushed a commit to humemai/arcadedb-embedded-python that referenced this pull request Jun 28, 2026
… 2.67.0 to 2.68.0 [skip ci]

Bumps [com.google.api.grpc:proto-google-common-protos](https://github.com/googleapis/sdk-platform-java) from 2.67.0 to 2.68.0.
Release notes

*Sourced from [com.google.api.grpc:proto-google-common-protos's releases](https://github.com/googleapis/sdk-platform-java/releases).*

> v2.68.0
> -------
>
> [2.68.0](googleapis/sdk-platform-java@v2.67.0...v2.68.0) (2026-03-17)
> ------------------------------------------------------------------------------------------------
>
> ### Features
>
> * Add client request duration metric. ([ArcadeData#4132](https://redirect.github.com/googleapis/sdk-platform-java/issues/4132)) ([6a76397](googleapis/sdk-platform-java@6a76397))
> * Add more attributes to golden signals metrics. ([ArcadeData#4135](https://redirect.github.com/googleapis/sdk-platform-java/issues/4135)) ([59d0624](googleapis/sdk-platform-java@59d0624))
> * **gax-httpjson:** add HttpJsonErrorParser utility ([ArcadeData#4137](https://redirect.github.com/googleapis/sdk-platform-java/issues/4137)) ([a1b7565](googleapis/sdk-platform-java@a1b7565))
> * **generator:** add extra allowed modules that will not be removed from the monorepo if they are present ([ArcadeData#4124](https://redirect.github.com/googleapis/sdk-platform-java/issues/4124)) ([774fe6e](googleapis/sdk-platform-java@774fe6e))
> * **o11y:** introduce `gcp.client.repo` and `gcp.client.artifact` attributes ([ArcadeData#4120](https://redirect.github.com/googleapis/sdk-platform-java/issues/4120)) ([105f644](googleapis/sdk-platform-java@105f644))
> * **o11y:** Introduce `rpc.system.name` and `rpc.method` in gRPC ([ArcadeData#4121](https://redirect.github.com/googleapis/sdk-platform-java/issues/4121)) ([7ab6d2e](googleapis/sdk-platform-java@7ab6d2e))
> * **o11y:** introduce server.port attribute ([ArcadeData#4128](https://redirect.github.com/googleapis/sdk-platform-java/issues/4128)) ([56aa343](googleapis/sdk-platform-java@56aa343))
>
> ### Bug Fixes
>
> * add null checks for ApiTracerFactory in ClientContext ([ArcadeData#4122](https://redirect.github.com/googleapis/sdk-platform-java/issues/4122)) ([4b3dbe2](googleapis/sdk-platform-java@4b3dbe2))
> * Decrease log level for directpath warnings outside GCE ([ArcadeData#4139](https://redirect.github.com/googleapis/sdk-platform-java/issues/4139)) ([c9651e7](googleapis/sdk-platform-java@c9651e7))
> * **gax-grpc:** add pick\_first fallback to direct path service config ([ArcadeData#4143](https://redirect.github.com/googleapis/sdk-platform-java/issues/4143)) ([b150fe9](googleapis/sdk-platform-java@b150fe9))
> * Populate method level attributes in metrics recording ([ArcadeData#4149](https://redirect.github.com/googleapis/sdk-platform-java/issues/4149)) ([7b7e6c9](googleapis/sdk-platform-java@7b7e6c9))
> * suppress warnings in generated projects for non-idiomatic durations ([ArcadeData#4119](https://redirect.github.com/googleapis/sdk-platform-java/issues/4119)) ([4206e6e](googleapis/sdk-platform-java@4206e6e))
> * Use ServiceName + MethodName as the regex for Otel ([ArcadeData#2543](https://redirect.github.com/googleapis/sdk-platform-java/issues/2543)) ([b9ae73f](googleapis/sdk-platform-java@b9ae73f))
>
> ### Documentation
>
> * **hermetic\_build:** fix config field name in readme ([ArcadeData#4130](https://redirect.github.com/googleapis/sdk-platform-java/issues/4130)) ([a0c8f67](googleapis/sdk-platform-java@a0c8f67))


Changelog

*Sourced from [com.google.api.grpc:proto-google-common-protos's changelog](https://github.com/googleapis/sdk-platform-java/blob/main/CHANGELOG.md).*

> [2.68.0](googleapis/sdk-platform-java@v2.67.0...v2.68.0) (2026-03-17)
> ------------------------------------------------------------------------------------------------
>
> ### Features
>
> * Add client request duration metric. ([ArcadeData#4132](https://redirect.github.com/googleapis/sdk-platform-java/issues/4132)) ([6a76397](googleapis/sdk-platform-java@6a76397))
> * Add more attributes to golden signals metrics. ([ArcadeData#4135](https://redirect.github.com/googleapis/sdk-platform-java/issues/4135)) ([59d0624](googleapis/sdk-platform-java@59d0624))
> * **gax-httpjson:** add HttpJsonErrorParser utility ([ArcadeData#4137](https://redirect.github.com/googleapis/sdk-platform-java/issues/4137)) ([a1b7565](googleapis/sdk-platform-java@a1b7565))
> * **generator:** add extra allowed modules that will not be removed from the monorepo if they are present ([ArcadeData#4124](https://redirect.github.com/googleapis/sdk-platform-java/issues/4124)) ([774fe6e](googleapis/sdk-platform-java@774fe6e))
> * **o11y:** introduce `gcp.client.repo` and `gcp.client.artifact` attributes ([ArcadeData#4120](https://redirect.github.com/googleapis/sdk-platform-java/issues/4120)) ([105f644](googleapis/sdk-platform-java@105f644))
> * **o11y:** Introduce `rpc.system.name` and `rpc.method` in gRPC ([ArcadeData#4121](https://redirect.github.com/googleapis/sdk-platform-java/issues/4121)) ([7ab6d2e](googleapis/sdk-platform-java@7ab6d2e))
> * **o11y:** introduce server.port attribute ([ArcadeData#4128](https://redirect.github.com/googleapis/sdk-platform-java/issues/4128)) ([56aa343](googleapis/sdk-platform-java@56aa343))
>
> ### Bug Fixes
>
> * add null checks for ApiTracerFactory in ClientContext ([ArcadeData#4122](https://redirect.github.com/googleapis/sdk-platform-java/issues/4122)) ([4b3dbe2](googleapis/sdk-platform-java@4b3dbe2))
> * Decrease log level for directpath warnings outside GCE ([ArcadeData#4139](https://redirect.github.com/googleapis/sdk-platform-java/issues/4139)) ([c9651e7](googleapis/sdk-platform-java@c9651e7))
> * **gax-grpc:** add pick\_first fallback to direct path service config ([ArcadeData#4143](https://redirect.github.com/googleapis/sdk-platform-java/issues/4143)) ([b150fe9](googleapis/sdk-platform-java@b150fe9))
> * Populate method level attributes in metrics recording ([ArcadeData#4149](https://redirect.github.com/googleapis/sdk-platform-java/issues/4149)) ([7b7e6c9](googleapis/sdk-platform-java@7b7e6c9))
> * suppress warnings in generated projects for non-idiomatic durations ([ArcadeData#4119](https://redirect.github.com/googleapis/sdk-platform-java/issues/4119)) ([4206e6e](googleapis/sdk-platform-java@4206e6e))
> * Use ServiceName + MethodName as the regex for Otel ([ArcadeData#2543](https://redirect.github.com/googleapis/sdk-platform-java/issues/2543)) ([b9ae73f](googleapis/sdk-platform-java@b9ae73f))
>
> ### Documentation
>
> * **hermetic\_build:** fix config field name in readme ([ArcadeData#4130](https://redirect.github.com/googleapis/sdk-platform-java/issues/4130)) ([a0c8f67](googleapis/sdk-platform-java@a0c8f67))


Commits

* [`7eca195`](googleapis/sdk-platform-java@7eca195) chore(main): release 2.68.0 ([ArcadeData#4123](https://redirect.github.com/googleapis/sdk-platform-java/issues/4123))
* [`7b7e6c9`](googleapis/sdk-platform-java@7b7e6c9) fix: Populate method level attributes in metrics recording ([ArcadeData#4149](https://redirect.github.com/googleapis/sdk-platform-java/issues/4149))
* [`c9651e7`](googleapis/sdk-platform-java@c9651e7) fix: Decrease log level for directpath warnings outside GCE ([ArcadeData#4139](https://redirect.github.com/googleapis/sdk-platform-java/issues/4139))
* [`55df486`](googleapis/sdk-platform-java@55df486) build(deps): bump black from 24.8.0 to 26.3.1 in /hermetic\_build/common ([ArcadeData#4138](https://redirect.github.com/googleapis/sdk-platform-java/issues/4138))
* [`15c8abf`](googleapis/sdk-platform-java@15c8abf) chore(deps): update upper bound dependencies file ([ArcadeData#4146](https://redirect.github.com/googleapis/sdk-platform-java/issues/4146))
* [`8be3f9d`](googleapis/sdk-platform-java@8be3f9d) chore: update googleapis commit at Thu Feb 19 03:02:27 UTC 2026 ([ArcadeData#4115](https://redirect.github.com/googleapis/sdk-platform-java/issues/4115))
* [`b150fe9`](googleapis/sdk-platform-java@b150fe9) fix(gax-grpc): add pick\_first fallback to direct path service config ([ArcadeData#4143](https://redirect.github.com/googleapis/sdk-platform-java/issues/4143))
* [`4a24d92`](googleapis/sdk-platform-java@4a24d92) build: disable SonarCloud for fork pull requests ([ArcadeData#4142](https://redirect.github.com/googleapis/sdk-platform-java/issues/4142))
* [`59d0624`](googleapis/sdk-platform-java@59d0624) feat: Add more attributes to golden signals metrics. ([ArcadeData#4135](https://redirect.github.com/googleapis/sdk-platform-java/issues/4135))
* [`0275698`](googleapis/sdk-platform-java@0275698) chore: extract channel builder for internal use ([ArcadeData#4136](https://redirect.github.com/googleapis/sdk-platform-java/issues/4136))
* Additional commits viewable in [compare view](googleapis/sdk-platform-java@v2.67.0...v2.68.0)
  
[![Dependabot compatibility score](https://dependabot-badges.githubapp.com/badges/compatibility\_score?dependency-name=com.google.api.grpc:proto-google-common-protos&package-manager=maven&previous-version=2.67.0&new-version=2.68.0)](https://docs.github.com/en/github/managing-security-vulnerabilities/about-dependabot-security-updates#about-compatibility-scores)
Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting `@dependabot rebase`.
[//]: # (dependabot-automerge-start)
[//]: # (dependabot-automerge-end)
---
Dependabot commands and options
  
You can trigger Dependabot actions by commenting on this PR:
- `@dependabot rebase` will rebase this PR
- `@dependabot recreate` will recreate this PR, overwriting any edits that have been made to it
- `@dependabot show  ignore conditions` will show all of the ignore conditions of the specified dependency
- `@dependabot ignore this major version` will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this minor version` will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
- `@dependabot ignore this dependency` will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
tae898 pushed a commit to humemai/arcadedb-embedded-python that referenced this pull request Jun 28, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

HASH index lookup returns no rows when data encryption is enabled

1 participant