Overview

The pipe object provides access to pipeline runtime information and metadata in expressions. These properties are available in any expression within a pipeline and provide context about the current execution, including parameters, identifiers, timing, and environment details.

Pipeline Parameters

pipe.args

A map containing all pipeline parameters as name/value pairs.

Syntax:

pipe.args
pipe.args["parameterName"]

Examples:

// Get all parameters as an object
pipe.args

// Access specific parameter
pipe.args["user"]           // Returns: value of "user" parameter
pipe.args["environment"]    // Returns: value of "environment" parameter

Pipeline Identification

pipe.instanceId

The UUID (Universally Unique Identifier) of the pipeline.

pipe.instanceId
// Returns: "1df92262-6d8a-4be9-bd0f-904e3d54f091"

pipe.label

The label (name) of the pipeline. If used in a child pipeline, returns the child pipeline name, not the parent.

pipe.label
// Returns: "My Pipeline Name"

pipe.projectPath

The path to the pipeline's project in SLFS (SnapLogic File System).

pipe.projectPath
// Returns: "/orgname/projects/projectname"

Runtime Identifiers

pipe.ruuid

The runtime Universal Unique Identifier of the current pipeline execution. This is a unique 61-character identifier for each pipeline run.

pipe.ruuid
// Returns: unique 61-character runtime ID

pipe.parentRuuid

The runtime UUID of the parent pipeline. In a child pipeline execution, this refers to the ruuid of the parent pipeline execution.

pipe.parentRuuid
// Returns: parent runtime UUID or null if no parent

pipe.rootRuuid

The root runtime UUID referring to the top-level execution started by a Task or by a user in Designer. Available in all descendant executions.

pipe.rootRuuid
// Returns: root execution runtime UUID (61 characters)

Execution Context

pipe.startTime

The start time of the pipeline execution.

pipe.startTime
// Returns: "2017-02-22T20:56:54.142 UTC"

pipe.flags.is_suggest

Indicates whether this is a normal execution or a pipeline validation in Designer.

pipe.flags.is_suggest
// Returns: true during Designer validation, false during normal execution

pipe.user

The ID of the user that executed the pipeline.

pipe.user
// Returns: "[email protected]"

Environment Information

pipe.hostname

The hostname of the host running the pipeline.

pipe.hostname
// Returns: hostname where the Snaplex is running the pipeline

pipe.plexPath

The path of the Snaplex executing the pipeline.

pipe.plexPath
// Returns: "/snaplogic/shared/cloud-dev"

pipe.tmpDir

A file URI referring to a temporary directory on the local disk for storing temporary files during pipeline execution. The directory is not created by default; Snaps must be configured to create intermediate directories. Contents are deleted after pipeline execution completes.

pipe.tmpDir
// Returns: "file:///tmp/snaplogic/xyz123"

Common Use Cases

Unique File Naming:

// Use ruuid for unique filenames
"/output/" + pipe.ruuid + "/data_" + Date.now() + ".json"

Environment-Specific Logic:

// Different behavior based on Snaplex
pipe.plexPath.includes("prod") ? $prodEndpoint : $devEndpoint

Audit Logging:

{
  "pipelineName": pipe.label,
  "executionId": pipe.ruuid,
  "startTime": pipe.startTime,
  "user": pipe.user,
  "environment": pipe.plexPath
}

Parameter Access:

// Access parameter by name
pipe.args["environment"]

// Check if parameter exists
"environment" in pipe.args

Temporary File Handling:

// Write to temp directory
pipe.tmpDir + "/intermediate_" + pipe.ruuid + ".csv"

Parent-Child Pipeline Tracking:

{
  "currentPipeline": pipe.label,
  "currentRuuid": pipe.ruuid,
  "parentRuuid": pipe.parentRuuid,
  "rootRuuid": pipe.rootRuuid
}

Conditional Execution:

// Skip certain logic during Designer validation
pipe.flags.is_suggest ? null : $actualProcessing

Best Practices

• Unique Identifiers: Use pipe.ruuid for generating unique identifiers in file names, database keys, or tracking records.
• Root Tracking: Use pipe.rootRuuid when you need to correlate data across parent and child pipeline executions.
• Environment Detection: Use pipe.plexPath or pipe.args to implement environment-specific logic (dev/staging/prod).
• Audit Trails: Include pipe.user, pipe.startTime, and pipe.ruuid in audit logs for traceability.
• Temporary Files: Use pipe.tmpDir for intermediate files that don't need to persist after pipeline execution.
• Designer Testing: Use pipe.flags.is_suggest to skip expensive operations during Designer validation.
• Pipeline Context: Use pipe.label and pipe.projectPath for self-documenting pipelines and dynamic configuration.

Property Reference

.org

Description:

The .org expression function returns the organization label for the current pipeline execution context. It provides a direct, reliable way to obtain the org label in expressions without parsing other properties such as pipe.projectPath.

Returns the organization label associated with the current pipeline execution context. Use .org instead of parsing pipe.projectPath when you need the org label directly.

Syntax:

.org

Arguments: None

Returns: String — the organization label (not the org path) for the current execution context.

Example:

.org
        // Returns: "TestCorp"

Examples

Build a fully qualified project asset path:

Use .org to construct stable, absolute paths that work across organizations and when launching from root shared. Reference the artifact name from a pipeline parameter using the underscore prefix.

'/' + .org + '/ProjectSpace/Project/' + _artifact_name

If .org is TestCorp and the pipeline parameter _artifact_name is MyPipeline, the expression evaluates to:

/TestCorp/ProjectSpace/Project/MyPipeline

Reference assets in shared projects:

Access the pipeline name from a pipeline parameter:

'/' + .org + '/shared/common/' + _pipeline_name

Compose with conditional logic:

Fallback to a default label if the value is not present

(.org ? '/' + .org : '/DefaultOrg') + '/Analytics/Jobs/' + $jobName

Best Practices

• Prefer .org over parsing pipe.projectPath when you need the org label directly.
• Use .org when pipelines may be promoted or moved between organizations.
• Use .org when executions are triggered from root shared or contexts where relative paths are unreliable.
• Keep path-building logic centralized — for example, via Pipeline Parameters or a shared expression — to ensure consistency.

Troubleshooting

Function Reference