Recording Gremlin Console Sessions to a File

During interactive exploration, debugging, or teaching, it is often useful to preserve a complete record of a Gremlin Console session. Recording allows commands and their corresponding results to be written to a file as they are executed. This is particularly valuable for:

 

·      Auditing or reviewing exploratory queries

·      Sharing reproducible examples with colleagues or students

·      Capturing output for documentation or reports

·      Retaining evidence of graph state during troubleshooting

 

The Gremlin Console provides built-in support for this workflow through the :record command.

 

The :record Command

Session recording is controlled entirely from within the console using the :record command. Recording can be started and stopped explicitly, allowing precise control over which portions of a session are captured.

 

The general form is:

 

·      :record start <file-path> - begin recording all subsequent commands and output

·      :record stop — end the recording and close the file

 

While recording is active, every Gremlin command entered and every result produced by the console is written to the specified file.

 

The following example demonstrates how to record a short Gremlin Console session to a file named mylog.txt.

 

Execute following statement from Gremlin console.

:record start /Users/Shared/mylog.txt

gremlin> :record start /Users/Shared/mylog.txt
Recording session to: "/Users/Shared/mylog.txt"
==>/Users/Shared/mylog.txt

   

From this point onward, all commands and results are captured until recording is stopped.

 

Let's create a Graph and Graph traversal instance by executing below statements.

 

graph = TinkerFactory.createModern()
g = traversal().with(graph)

gremlin> graph = TinkerFactory.createModern()
==>tinkergraph[vertices:6 edges:6]
gremlin> g = traversal().with(graph)
==>graphtraversalsource[tinkergraph[vertices:6 edges:6], standard]

The traversal source, typically named g, serves as the entry point for all Gremlin queries against the graph.

 

With recording enabled, traversals and their results are written to the log file automatically.

 

The following traversal counts the total number of vertices in the graph:

gremlin> g.V().count().next()
==>6

   

Here, V() selects all vertices, count() computes the total, and next() retrieves the scalar result from the traversal. The next traversal retrieves a detailed view of each vertex, including identifiers, labels, and properties:

 

gremlin> g.V().valueMap(true)
==>[id:1,label:person,name:[marko],age:[29]]
==>[id:2,label:person,name:[vadas],age:[27]]
==>[id:3,label:software,name:[lop],lang:[java]]
==>[id:4,label:person,name:[josh],age:[32]]
==>[id:5,label:software,name:[ripple],lang:[java]]
==>[id:6,label:person,name:[peter],age:[35]]

The valueMap(true) step includes both element identifiers and labels, making it useful for inspection and debugging. A detailed explanation of Gremlin traversals and steps follows in subsequent sections of this tutorial.

 

Stopping the Recording

Once the relevant portion of the session has been captured, recording is stopped explicitly by exeucting below command.

:record stop

gremlin> :record stop
Recording stopped; session saved as: "/Users/Shared/mylog.txt" (435 bytes)
==>/Users/Shared/mylog.txt

At this point, the file is closed and no further console activity is written to it.

 

Inspecting the Recorded Output

Opening the generated mylog.txt file reveals a structured, chronological record of the session.

$cat /Users/Shared/mylog.txt 
// OPENED: Fri Jan 09 14:14:12 IST 2026
// RESULT: /Users/Shared/mylog.txt
graph = TinkerFactory.createModern()
// RESULT: tinkergraph[vertices:6 edges:6]
g = traversal().with(graph)
// RESULT: graphtraversalsource[tinkergraph[vertices:6 edges:6], standard]
g.V().count().next()
// RESULT: 6
g.V().valueMap(true)
// RESULT: [TinkerGraphStep(vertex,[]), PropertyMapStep(null,value)]
:record stop
// CLOSED: Fri Jan 09 14:17:41 IST 2026

Each command is followed by a // RESULT: line containing the console’s response. The file also includes timestamps marking when recording began and ended, providing useful contextual information for later review.

 

When using session recording, keep the following points in mind:

 

·      Recording captures both commands and results, not just output

·      Absolute or relative file paths may be used, depending on the environment

·      Sensitive data should be handled carefully when sharing recorded files

·      Recorded sessions can serve as executable documentation, but may require minor cleanup for presentation purposes

 

Used thoughtfully, the :record command transforms the Gremlin Console into a powerful tool for reproducibility, learning, and collaboration.

 

 

Previous                                                    Next                                                    Home