You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@tinkerpop.apache.org by ke...@apache.org on 2026/07/17 23:35:03 UTC
(tinkerpop) branch master updated: Improve 4-beta3 documentation CTR.
This is an automated email from the ASF dual-hosted git repository.
kenhuuu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/tinkerpop.git
The following commit(s) were added to refs/heads/master by this push:
new 4ccb9d1f87 Improve 4-beta3 documentation CTR.
4ccb9d1f87 is described below
commit 4ccb9d1f87bdb19641c923a67912f6671bb12cf8
Author: Ken Hu <10...@users.noreply.github.com>
AuthorDate: Fri Jul 17 13:54:49 2026 -0700
Improve 4-beta3 documentation CTR.
Document canonical Gremlin literal syntax
Update maxConnections references
Remove stale driver pool option docs
Document semantics for new primitive types
Document scriptEngines behavior
Document GLV transaction source handles
Clarify managed transaction upgrade docs
Clarify Python driver upgrade docs
Assisted-by: Codex:gpt-5.5
---
docs/src/dev/provider/gremlin-semantics.asciidoc | 16 ++-
docs/src/reference/gremlin-applications.asciidoc | 27 +++++-
docs/src/reference/gremlin-variants.asciidoc | 24 ++++-
docs/src/reference/the-traversal.asciidoc | 44 +++++++++
docs/src/upgrade/release-4.x.x.asciidoc | 108 ++++++++++-----------
.../apache/tinkerpop/gremlin/driver/Client.java | 2 +-
6 files changed, 152 insertions(+), 69 deletions(-)
diff --git a/docs/src/dev/provider/gremlin-semantics.asciidoc b/docs/src/dev/provider/gremlin-semantics.asciidoc
index b13b13e6dc..5ccfcd9112 100644
--- a/docs/src/dev/provider/gremlin-semantics.asciidoc
+++ b/docs/src/dev/provider/gremlin-semantics.asciidoc
@@ -250,20 +250,30 @@ any non-`null` value.
For Booleans, `TRUE == TRUE`, `FALSE == FALSE`, `TRUE != FALSE`, and `FALSE < TRUE`.
-===== STRING
+===== STRING / CHAR
-We assume the common lexicographical order over unicode strings. `A` and `B` are compared lexicographically, and
-`A == B` if `A` and `B` are lexicographically equal.
+We assume the common lexicographical order over unicode strings and characters. `A` and `B` are compared
+lexicographically, and `A == B` if `A` and `B` are of the same type and lexicographically equal.
===== UUID
UUID is evaluated based on its String representation. However, `UUID("b46d37e9-755c-477e-9ab6-44aabea51d50")` and the
String `"b46d37e9-755c-477e-9ab6-44aabea51d50"` are not <<Equality,Equal>> and not <<Comparability,Comparable>>.
+===== BINARY
+
+Binary values are evaluated based on lexicographical comparison of their byte sequences, comparing each byte as a
+signed 8-bit value. `A == B` if `A` and `B` have the same bytes in the same order.
+
===== DATETIME
Dates are evaluated based on the numerical comparison of Unix Epoch time.
+===== DURATION
+
+Durations are evaluated based on the numerical comparison of their total length. `A == B` if `A` and `B` represent the
+same total length.
+
===== Graph Elements (VERTEX / EDGE / VPROPERTY)
If they are the same type of Element, these are compared by the value of their `T.id` according to the semantics for
diff --git a/docs/src/reference/gremlin-applications.asciidoc b/docs/src/reference/gremlin-applications.asciidoc
index 06b6c95011..04e1d43e67 100644
--- a/docs/src/reference/gremlin-applications.asciidoc
+++ b/docs/src/reference/gremlin-applications.asciidoc
@@ -840,8 +840,7 @@ possible to define the language to utilize to process the request:
[source,text]
curl -X POST -d "{\"gremlin\":\"100-x\", \"language\":\"gremlin-groovy\", \"parameters\":\"[x:1]\"}" "http://localhost:8182"
-By default this value is set to `gremlin-groovy`. If using a `GET` operation, this value can be set as a query
-string argument with by setting the `language` key.
+By default this value is set to `gremlin-lang`. The value is set in the request body with the `language` key.
[[server-configuring]]
=== Configuring
@@ -955,7 +954,7 @@ The following table describes the various YAML configuration options that Gremli
|metrics.slf4jReporter.intervalMillis |Time in milliseconds between reports of metrics to SLF4j. |180000
|port |The port to bind the server to. |8182
|resultIterationBatchSize |Defines the size in which the result of a request is "batched" back to the client. In other words, if set to `1`, then a result that had ten items in it would get each result sent back individually. If set to `2` the same ten results would come back in five batches of two each. |64
-|scriptEngines |A `Map` of `ScriptEngine` implementations to expose through Gremlin Server, where the key is the name given by the `ScriptEngine` implementation. The key must match the name exactly for the `ScriptEngine` to be constructed. The value paired with this key is itself a `Map` of configuration for that `ScriptEngine`. If this value is not set, it will default to "gremlin-lang". |_gremlin-lang_
+|scriptEngines |A `Map` of `ScriptEngine` configurations keyed by `ScriptEngine` name. See <<server-scriptengines-behavior>>. |_gremlin-lang_
|scriptEngines.<name>.imports |A comma separated list of classes/packages to make available to the `ScriptEngine`. |_none_
|scriptEngines.<name>.staticImports |A comma separated list of "static" imports to make available to the `ScriptEngine`. |_none_
|scriptEngines.<name>.scripts |A comma separated list of script files to execute on `ScriptEngine` initialization. Deprecated — use `traversalSources` and `lifecycleHooks` instead.|_none_
@@ -987,6 +986,28 @@ The following table describes the various YAML configuration options that Gremli
See the <<metrics,Metrics>> section for more information on how to configure Ganglia and Graphite.
+[[server-scriptengines-behavior]]
+==== scriptEngines Behavior
+
+The `scriptEngines` configuration identifies the `ScriptEngine` implementations to expose through Gremlin Server.
+The key is the name given by the `ScriptEngine` implementation and must match that name exactly. The value paired with
+this key is itself a `Map` of configuration for that `ScriptEngine`.
+
+Only `ScriptEngine` implementations listed in the configuration will accept requests. The `gremlin-lang`
+`ScriptEngine` is always available regardless of configuration.
+
+A request that specifies an unlisted `language` will receive a `400 Bad Request` response. Enabling `gremlin-groovy` or
+another `ScriptEngine` therefore requires an explicit entry in `scriptEngines`:
+
+[source,yaml]
+----
+scriptEngines: {
+ gremlin-lang: {},
+ gremlin-groovy: {
+ plugins: {
+ org.apache.tinkerpop.gremlin.server.jsr223.GremlinServerGremlinPlugin: {}}}}
+----
+
==== Serialization
Gremlin Server can accept requests and return results using different serialization formats. Serializers implement the
diff --git a/docs/src/reference/gremlin-variants.asciidoc b/docs/src/reference/gremlin-variants.asciidoc
index fa27b616bf..3bc95a6fb7 100644
--- a/docs/src/reference/gremlin-variants.asciidoc
+++ b/docs/src/reference/gremlin-variants.asciidoc
@@ -419,6 +419,9 @@ err = tx.Commit()
if err != nil { log.Fatal(err) }
----
+The transaction-bound source retains its owning transaction. Calling `gtx.Tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as `gtx.Tx().Commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides closure methods that manage the
@@ -724,6 +727,8 @@ therefore cardinality functions that take a value like `list()`, `set()`, and `s
[[gremlin-go-limitations]]
=== Limitations
+* The Gremlin `Character` type is not supported by Gremlin-Go.
+
* There is no default `set` type in Go. Any set type code from server will be deserialized into slices with the list
type implementation. To input a set into Gremlin-Go, a custom struct which implements the `gremlingo.Set` interface
will be serialized as a set. `gremlingo.NewSimpleSet` is a basic implementation of a set that is provided by Gremlin-Go
@@ -1153,6 +1158,9 @@ try {
Traversals spawned from `gtx` are bound to the transaction. The driver handles host pinning and transaction ID
propagation automatically.
+The transaction-bound source retains its owning transaction. Calling `gtx.tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as `gtx.tx().commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` also provides closure methods that manage the
@@ -1640,9 +1648,7 @@ where this occurs:
The latter of the two can be addressed from the driver side in the following ways:
* Increase the `maxWaitForConnection` allowing the client to wait a bit longer for a connection to become available.
-* Increase the number of requests allowed per connection by increasing the `maxSimultaneousUsagePerConnection` and
-`maxInProcessPerConnection` settings.
-* Increase the number of connections available in the connection pool by increasing the `maxConnectionPoolSize`.
+* Increase the number of connections available in the connection pool by increasing the `maxConnections`.
The exception and logs (assuming they are enabled) should contain information about the state of the connection pool
along with its connections which can help shed more light on which of these scenarios caused the problem. Some examples
@@ -1660,7 +1666,7 @@ _Client is likely issuing more requests than the pool size can handle_
[source,text]
----
-Timed-out (150 MILLISECONDS) waiting for connection on Host{address=localhost/127.0.0.1:45940, hostUri=http://localhost:45940/gremlin}. Potential Cause: Number of active requests exceeds pool size. Consider increasing the value for maxConnectionPoolSize.
+Timed-out (150 MILLISECONDS) waiting for connection on Host{address=localhost/127.0.0.1:45940, hostUri=http://localhost:45940/gremlin}. Potential Cause: Number of active requests (1) exceeds pool size (1). Consider increasing the value for maxConnections.
ConnectionPool (Host{address=localhost/127.0.0.1:45940, hostUri=http://localhost:45940/gremlin})
Connection Pool Status (size=1 available=1 max=1 toCreate=0 bin=0 waiter=0)
> Connection{channel=5a859d62 isDead=false borrowed=1 pending=1 markedReplaced=false closing=false created=2022-12-19T21:08:21.569613100Z thread=gremlin-driver-conn-scheduler-1}
@@ -2180,6 +2186,9 @@ await gtx.addV("person").property("name", "josh").iterate();
await tx.commit();
----
+The transaction-bound source retains its owning transaction. Calling `gtx.tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as `await gtx.tx().commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides an `executeInTx` method that manages the
@@ -2501,6 +2510,7 @@ exact type sent to the server — see <<gremlin-javascript-numeric-types>>.
signed range are unsuffixed (Int), integers beyond that up to `Number.MAX_SAFE_INTEGER` use the `L` suffix (Long),
non-integer numbers and integers beyond the safe range use the `D` suffix (Double), and `BigInt` values use the `N`
suffix (BigInteger).
+* Gremlin `Character` and `Duration` values are not supported.
* The `subgraph()`-step returns a detached `Graph` data container exposing
`vertices: Map<any, Vertex>` and `edges: Map<any, Edge>`. The result is not a live `Graph` instance: mutating the
collections has no effect on the source graph, and it cannot be passed to `traversal().with(...)`. To re-query
@@ -2867,6 +2877,9 @@ await gtx.AddV("person").Property("name", "josh").Promise(t => t.Iterate());
await tx.CommitAsync();
----
+The transaction-bound source retains its owning transaction. Calling `gtx.Tx()` returns the same `RemoteTransaction`,
+so lifecycle operations can also be performed from the source with calls such as `await gtx.Tx().CommitAsync()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides closure methods that manage the
@@ -3577,6 +3590,9 @@ gtx.addV('person').property('name', 'josh').iterate()
tx.commit()
----
+The transaction-bound source retains its owning transaction. Calling `gtx.tx()` returns the same `Transaction`, so
+lifecycle operations can also be performed from the source with calls such as `gtx.tx().commit()`.
+
==== Managed Transaction Blocks
To avoid the manual begin/commit/rollback boilerplate, `g` provides an `execute_in_tx` method that manages the
diff --git a/docs/src/reference/the-traversal.asciidoc b/docs/src/reference/the-traversal.asciidoc
index a44084506a..5a849914d9 100644
--- a/docs/src/reference/the-traversal.asciidoc
+++ b/docs/src/reference/the-traversal.asciidoc
@@ -153,6 +153,10 @@ GraphTraversalSource gtx2 = tx2.begin();
// g operates outside of both tx1 and tx2
----
+The transaction-bound `GraphTraversalSource` can also act as the transaction handle. Calling `gtx.tx()` (or the
+language-specific casing equivalent) returns the same `Transaction`, which allows code that only passes `gtx` through a
+helper to still close the transaction with `gtx.tx().commit()` or `gtx.tx().rollback()`.
+
In remote cases, `GraphTraversalSource` instances spawned from `begin()` are safe to use from a single thread. The
default behavior of `close()` on a `Transaction` for remote cases is to `rollback()`, ensuring partial work is
discarded if the user forgets to commit. Users must call `commit()` explicitly to persist data.
@@ -6174,6 +6178,46 @@ By default, `GType` enumerations are registered using their simple class names a
g.V().values('age','name').is(P.typeOf('Integer'))
----
+[[canonical-gremlin-literal-types]]
+=== Canonical Gremlin Literal Types
+
+Canonical Gremlin represents typed values as text so that scripts and GLV requests can be expressed in the
+`gremlin-lang` language and parsed by the `gremlin-lang` script engine. The authoritative definition of this syntax is
+the link:https://github.com/apache/tinkerpop/blob/x.y.z/gremlin-language/src/main/antlr4/Gremlin.g4[Gremlin.g4 ANTLR grammar].
+This section summarizes the commonly used literal forms for convenience when reading canonical Gremlin or writing direct
+script requests.
+
+[width="100%",cols="2,3,6",options="header"]
+|=========================================================
+|Type |Canonical form |Expected input
+|null |`null` |The literal keyword `null`.
+|Boolean |`true`, `false` |The literal keywords `true` and `false`.
+|String |`"marko"`, `'marko'`, `"M"s` |A single-quoted or double-quoted string. The optional `s` suffix still produces a `String`.
+|Character |`"M"c`, `'M'c` |A single-quoted or double-quoted value that is one character.
+|Byte |`1B` |An integer with a `B` suffix and a value within the bounds of `Byte`.
+|Short |`1S` |An integer with an `S` suffix and a value within the bounds of `Short`.
+|Integer |`1`, `1I` |An integer within the bounds of `Integer`. The `I` suffix forces `Integer`.
+|Long |`1L` |An integer with an `L` suffix and a value within the bounds of `Long`.
+|BigInteger |`1N` |An integer with an `N` suffix.
+|Float |`1.0F` |A floating-point number with an `F` suffix and a value within the bounds of `Float`.
+|Double |`1.0`, `1.0D` |A floating-point number with an optional `D` suffix.
+|BigDecimal |`1.0M` |A floating-point number with an `M` suffix.
+|DateTime |`DateTime("2018-03-22T00:35:44Z")`, `DateTime()` |An ISO-8601 date or date-time string. `DateTime()` evaluates to the current time.
+|UUID |`UUID("f47af10b-58cc-4372-a567-0f02b2f3d479")`, `UUID()` |A UUID string in the textual form written as 8-4-4-4-12 hexadecimal digit groups. `UUID()` generates a random UUID.
+|Duration |`Duration(3600,0)`, `Duration(30,0,false)` |The first argument is non-negative seconds. The second is nanoseconds from `0` to `999999999`. The optional third argument is a boolean sign flag with `false` negating the duration.
+|Binary |`Binary("AQID")` |A Base64-encoded string.
+|Enum |`T.id`, `Cardinality.single`, `Direction.OUT` |A Gremlin enum token from `T`, `Cardinality`, `Direction`, `Merge`, `Pick`, `DT`, or `GType`.
+|List |`[1,"two",null]` |A comma-separated sequence of generic literals inside square brackets.
+|Set |`{1,"two"}` |A comma-separated sequence of generic literals inside braces.
+|Map |`[:]`, `["name":"marko", "age":29]` |An empty map is `[:]`. A populated map is a comma-separated sequence of `key:value` entries inside square brackets.
+|Provider Defined Type |`PDT("Point",["x":1,"y":2])`, `PDT("Uint32","42")` |The first argument is the provider-defined type name. The composite form expects a map literal with string keys. The primitive form expects an opaque string value.
+|=========================================================
+
+NOTE: Numeric values may be signed, and integer values may use decimal, hexadecimal (`0x`), or octal (`0`) notation.
+Underscores may appear between digits. Numeric type suffixes are accepted in either uppercase or lowercase form, though
+the examples above use uppercase suffixes. Special floating-point values are expressed as `NaN`, `Infinity`,
+`+Infinity`, or `-Infinity`.
+
[[a-note-on-maps]]
== A Note on Maps
diff --git a/docs/src/upgrade/release-4.x.x.asciidoc b/docs/src/upgrade/release-4.x.x.asciidoc
index 5221c0a9a0..bd9e9f02b1 100644
--- a/docs/src/upgrade/release-4.x.x.asciidoc
+++ b/docs/src/upgrade/release-4.x.x.asciidoc
@@ -214,33 +214,40 @@ Each GLV provides two entry points:
* **Traversal API**: `g.tx().begin()` returns a transaction-bound `GraphTraversalSource`
* **Driver API**: `client.transact()` (or `client.Transact()` in .NET) returns a `Transaction` with `submit()` methods
-See the <<gremlin-drivers-variants,Gremlin Drivers and Variants>> reference documentation for language-specific
-syntax and examples.
+See the link:https://tinkerpop.apache.org/docs/4.0.0-beta.3/reference/#gremlin-drivers-variants[Gremlin Drivers and Variants]
+reference documentation for language-specific syntax and examples.
===== Managed Transaction Blocks
-In addition to the manual `begin()`/`commit()`/`rollback()` lifecycle, every GLV (including the Java driver and embedded
-Java graphs) now offers closure-based convenience methods directly on `GraphTraversalSource` (`g`). You hand `g` a
-function that receives the transaction-bound `g` (`gtx`), and the transaction lifecycle is managed for you: the
-transaction is begun, your function runs, and it is committed on normal completion or rolled back if your function
-raises. This reduces the common begin/do-work/commit boilerplate and makes it harder to accidentally run a traversal
-against the non-transactional `g`, since only the transactional source is in scope inside the closure. The methods are a
-Traversal-API convenience (they live on `g`, not on the `Transaction` returned by `g.tx()`).
-
-The method naming follows each language's idiom (the value-returning form is `evaluateInTx` rather than `call`, because
-`call` is already the `call()` service step on `GraphTraversalSource`):
-
-* **Java**: `g.executeInTx(Consumer)` (no return) and `g.evaluateInTx(Function)` (returns the body's value).
-* **Python**: `g.execute_in_tx(fn)` — a single method that returns whatever the function returns.
-* **JavaScript**: `await g.executeInTx(fn)` — the callback may be `async`; resolves to the callback's return value.
-* **.NET**: `g.ExecuteInTxAsync(Func<..,Task>)` and `g.EvaluateInTxAsync<T>(Func<..,Task<T>>)`, both accepting an optional `CancellationToken`.
-* **Go**: `g.ExecuteInTx(func(*GraphTraversalSource) error) error` and `g.EvaluateInTx(func(*GraphTraversalSource) (interface{}, error)) (interface{}, error)`.
-
-The closure runs the transaction exactly once (no automatic retry). If the function fails, the original error is
-re-raised after rollback; if `commit()` fails, the commit error is raised and a rollback is still attempted to release
-server-side resources. The manual `begin()`/`commit()`/`rollback()` API remains available and unchanged for advanced
-use. See the <<gremlin-drivers-variants,Gremlin Drivers and Variants>> reference documentation for language-specific
-examples.
+Managed transaction blocks provide a shorter way to run a unit of work in a transaction. The application passes a
+closure to `g`, receives a transaction-bound `gtx`, and the transaction will be committed when the closure completes
+normally or rolled back when the closure throws.
+
+[source,java]
+----
+// before: manage the transaction lifecycle directly
+Transaction tx = g.tx();
+GraphTraversalSource gtx = tx.begin();
+try {
+ gtx.addV("person").property("name", "alice").iterate();
+ gtx.addV("software").property("name", "graph-app").iterate();
+ tx.commit();
+} catch (RuntimeException ex) {
+ tx.rollback();
+ throw ex;
+}
+
+// now: let the traversal source manage the lifecycle
+g.executeInTx(gtx -> {
+ gtx.addV("person").property("name", "alice").iterate();
+ gtx.addV("software").property("name", "graph-app").iterate();
+});
+----
+
+The same managed transaction pattern is supported in every GLV, with method names following each language's
+conventions. See the
+link:https://tinkerpop.apache.org/docs/4.0.0-beta.3/reference/#gremlin-drivers-variants[Gremlin Drivers and Variants]
+reference documentation for language-specific syntax and error-handling details.
See: link:https://issues.apache.org/jira/browse/TINKERPOP-3253[TINKERPOP-3253]
@@ -527,8 +534,6 @@ A character literal is a single-character string with a `c` suffix:
g.V().has("initial","M"c)
----
-NOTE: Character is not supported in gremlin-go or gremlin-javascript.
-
===== Duration
A duration literal uses seconds and nanoseconds with an optional sign flag:
@@ -567,48 +572,26 @@ g.V().has("blob",P.eq(Binary("AQID")))
See: link:https://issues.apache.org/jira/browse/TINKERPOP-3153[TINKERPOP-3153]
-==== Python Driver Simplification — Removed GraphSON, Abstract Base Classes, and Protocol Layer
-
-The `AbstractBaseTransport`, `AbstractBaseProtocol`, and `GremlinServerHTTPProtocol` classes have been removed from
-`gremlin-python`. The protocol layer's request-building logic (serialization, headers, interceptors, auth) has been
-merged directly into `Connection`. The driver now uses `AiohttpHTTPTransport` directly without an abstract transport
-interface.
+==== Python Driver Simplification
-`GremlinServerError` has moved from `gremlin_python.driver.protocol` to `gremlin_python.driver.connection`:
-
-The `GraphSONSerializersV4` class and the `gremlin_python.structure.io.graphsonV4` module have been removed.
-GraphBinary is the only supported wire format for the Python driver in TinkerPop 4. Code that constructed
-`GraphSONSerializersV4()` or imported from `gremlin_python.structure.io.graphsonV4` must switch to
-`GraphBinarySerializersV4` (the default `response_serializer`):
-
-[source,python]
-----
-# Before
-from gremlin_python.driver.protocol import GremlinServerError
-
-# After
-from gremlin_python.driver.connection import GremlinServerError
-----
-
-The `protocol_factory` and `transport_factory` parameters have been removed from `Client`,
-`DriverRemoteConnection`, and `Connection`. Users who were passing a custom `protocol_factory` should use the
-`response_serializer`, `auth`, and `interceptors` parameters directly instead. These cover all functionality that
-`GremlinServerHTTPProtocol` previously provided.
-
-Transport options like SSL and timeouts are now passed as keyword arguments directly:
+Gremlin for Python has been heavily refactored for this release, simplifying driver usage and removing unnecessary
+infrastructure. Key areas for change to consider when upgrading include removal of the old mechanism used to configure
+a custom `transport_factory`, which was commonly used to pass SSL and timeout options into the underlying transport.
+Those settings now pass directly to `Client` or `DriverRemoteConnection`:
[source,python]
----
# Before
from gremlin_python.driver.aiohttp.transport import AiohttpHTTPTransport
+
Client(url, 'g', transport_factory=lambda: AiohttpHTTPTransport(ssl_options=ctx, read_timeout=30))
# After
Client(url, 'g', ssl=ctx, read_timeout=30)
----
-The `Connection` constructor signature has changed. The `protocol` and `transport_factory` positional arguments have
-been removed. Transport kwargs are forwarded to `AiohttpHTTPTransport` internally:
+The lower-level `Connection` API follows the same simplification. The old protocol and transport factory arguments have
+been removed, and serializer, authentication, interceptor, and transport settings are configured directly:
[source,python]
----
@@ -621,9 +604,18 @@ Connection(url, traversal_source, executor, pool,
auth=None, interceptors=None, **transport_kwargs)
----
-Custom transport implementations are no longer supported. The driver uses `AiohttpHTTPTransport` directly.
+`GremlinServerError` now imports from `gremlin_python.driver.connection`:
+
+[source,python]
+----
+# Before
+from gremlin_python.driver.protocol import GremlinServerError
+
+# After
+from gremlin_python.driver.connection import GremlinServerError
+----
-See: link:https://tinkerpop.apache.org/docs/4.0.0/reference/#gremlin-python[Gremlin-Python]
+See: link:https://tinkerpop.apache.org/docs/4.0.0-beta.3/reference/#gremlin-python[Gremlin-Python]
==== Removal of sparql-gremlin
diff --git a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java
index 2348884b60..adb93f6335 100644
--- a/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java
+++ b/gremlin-driver/src/main/java/org/apache/tinkerpop/gremlin/driver/Client.java
@@ -58,7 +58,7 @@ public abstract class Client implements RequestSubmitter, RequestSubmitterAsync
private static final Logger logger = LoggerFactory.getLogger(Client.class);
public static final String TOO_MANY_IN_FLIGHT_REQUESTS = "Number of active requests (%s) exceeds pool size (%s). " +
- "Consider increasing the value for maxConnectionPoolSize.";
+ "Consider increasing the value for maxConnections.";
protected final Cluster cluster;
protected volatile boolean initialized;