# Context (Execution)

The `Context` class provides access to various runtime context information, allowing you to interact with the environment and retrieve essential data. Using this class, you can access the current running execution. 

*Note: Context Class will not be available when workflow is stopped.*

### Methods

#### `static getIteration(): Long`

Returns the iteration number of the current execution as a `Long`. 

```typescript
Context.getIteration(); // returns iteration number
```

#### `static getNodeId(): String`

Use this method to retrieve the unique node identifier as a `String`.

```typescript
Context.NodeId(); // returns ID of current node
```

#### `static getStartedBy(): JsonNode`

Returns the data associated with the user user who started the workflow.

```typescript
Context.getStartedBy(); // returns JSON object
```

#### `static getCreatedBy(): JsonNode`

Returns the data associated with the user who created the workflow.

```typescript
Context.getCreatedBy(); // returns JSON object
```

#### `static environment(): String`

This method returns the environment in which the workflow is executed, such as "development" or "production."

```typescript
Context.environment();
```

#### `static isProd(): Boolean`

Use this method to determine if the current environment is "production." It returns `true` if the script is running in a production environment; otherwise, it returns `false`.

```typescript
Context.isProd(); // returns boolean
```

#### `static isDev(): Boolean`

Similarly, you can check if the current environment is "development" using this method. It returns `true` for development environments and `false` otherwise.

```typescript
Context.isDev(); // returns boolean
```

#### `static configs(): JsonNode`

This method provides access to configuration data in the form of a JSON node. You can use it to retrieve and manipulate configuration settings.

```typescript
Context.configs(); // returns JSON object
```

#### `static stats(): JsonNode`

Returns statistical data in the form of a JSON node, allowing you to access execution statistics.

```typescript
Context.stats(); // returns JSON object
```

#### `static getExecutionId(): String`

Retrieve the execution ID as a `String`. This can be useful for tracking and logging purposes.

```typescript
Context.getExecutionId();
```

#### `static getName(): String`

Obtain the name associated with the execution context as a `String`. This may be a human-readable identifier or a descriptive name for the execution context.

```typescript
Context.getName();
```

#### `static sleep(Long: millis): void` (Experimental)

In this example the iteration will wait 5 seconds without blocking the main thread

```typescript
Context.sleep(Long.parseLong("5000"));
```

The `Context` class empowers your custom scripts to access critical information about the runtime environment and the current execution context, making it a valuable tool for building versatile and context-aware applications.

### **Examples**

**Example**: Accessing Runtime Context Information.

```typescript
// Check the current environment
var isProduction = Context.isProd();
var isDevelopment = Context.isDev();

var environmentStatus = "Current Environment: ";
if (isProduction) {
    environmentStatus += "Production";
} else if (isDevelopment) {
    environmentStatus += "Development";
} else {
    environmentStatus += "Unknown";
}

// Get information about the execution
var executionId = Context.getExecutionId();
var executionName = Context.getName();

// Display the collected information
var executionInfo = "Execution ID: " + executionId + "\nExecution Name: " 
                                     + executionName;
var contextInfo = environmentStatus + "\n\n" + executionInfo;

return contextInfo;
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.b2winsuite.com/6.1/scripting/contexts/context-execution.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.