Glossary

Definitions for the terms the Functions documentation uses.

Term	Definition
Args	The JSON object a function instance passes into the execution context of the function. An instance overrides, key by key, the default Args set on the function. How it works shows how the two combine.
Azion Bundler	The open-source framework adapter that transforms a framework project into functions that run on Azion Runtime. How it works describes the four stages of the build, from framework detection to the deployment of the generated functions.
Azion Runtime	The environment that executes the handler of a function. Azion Runtime runs JavaScript built on Web standards, so a function calls Web APIs rather than a proprietary interface.
Cell	The isolation environment a function runs inside, based on V8 isolates. Each Cell is a lightweight execution context with no direct access to the underlying operating system, which is why a function cannot read OS properties, resolve DNS through native system calls, or open low-level sockets. Node.js compatibility lists what that excludes.
code editor	The editor in Azion Console where you write and edit the code of a function. The code editor runs the Monaco editor from VS Code, and shows the output of the function through Preview deployment.
CPU time	The active computation a single invocation performs, capped at 2 seconds. It excludes time spent waiting on `fetch()`, so a function that waits on an origin stays far from this ceiling however long the request takes. A function that exceeds it is terminated. Compare wall-clock time, and refer to Limits.
environment variable	A value stored outside the code of a function and read from the `env` parameter of the handler. Environment variables keep API keys, credentials, and access tokens out of the codebase.
ES Modules pattern	The handler pattern new code uses: a function exports a default object whose `fetch` method receives `request`, `env`, and `ctx`. Best practices compares it with the Service Worker pattern, and Handlers documents the signature.
execution context	The `ctx` parameter a handler receives, after `request` and `env`. `ctx.waitUntil(promise)` extends the lifetime of the execution beyond the point where the handler returns, and on a firewall handler `ctx.deny()` blocks the request immediately. Handlers lists every parameter of both handlers.
execution phase	The stage of request processing a Rules Engine rule belongs to. Request Phase handles what the user sent, and Response Phase handles what the application returns. How it works describes both phases and the criteria that trigger a rule.
function	The JavaScript code you create in Functions. A function belongs to the product rather than to a single application, so the same code can be instantiated in more than one place. Creating a function does not execute it: an instance and a rule invoke it, as How it works describes.
function instance	The object that binds one function to one application or to one firewall, and carries the Args passed into its execution context. Instantiation does not open the code for editing: an instance sets only the Args.
Functions Event Collector	The Data Stream template that formats the log messages of your functions for the endpoint that receives them. The preset fills the data set with the request identifier, the log level, and the log message. Troubleshooting lists every variable it carries.
handler	The function your code exports for Azion Runtime to execute. In an application the handler is named `fetch`; on a firewall it is named `firewall` and can call `ctx.deny()` to block the request. Handlers documents the parameters both receive.
isolate	The V8 execution context in which one invocation of a function runs. The memory limit of a function applies per isolate, and Limits carries the value.
Preview deployment	The feature that shows the output of a function beside the code editor, before the function serves production traffic. Preview deployment renders the outcome of `PreviewProvider`, an auxiliary function in your source code.
PreviewProvider	The auxiliary function in your source code that builds a simulated request for Preview deployment. Without it, the preview has nothing to render.
Run Function	The Rules Engine behavior that invokes a function instance. The rule carries the execution phase and the criteria that trigger it, and nothing else invokes a function. The behavior requires the Application Accelerator module.
secret	The boolean field on an environment variable that states whether the value is confidential. Azion CLI sets the field with the `--secret` flag, which defaults to `true`.
sub-request	An outbound `fetch()` call a function makes during one invocation, capped at 50. The ceiling is per invocation rather than per second, so it bounds the shape of the code and not the traffic the application receives. Best practices covers the consolidation this forces.
Service Worker pattern	The handler pattern that registers a listener with `addEventListener('fetch', ...)` and reads the request, the environment, and the execution context from an event object. Azion maintains it for backward compatibility and recommends migrating functions that still use it, as Best practices describes. Migrate handler patterns in Functions shows the before and after of each handler.
wall-clock time	The total elapsed time of one invocation, capped at 5 minutes, including I/O wait, `fetch()` calls, and async operations. It is the ceiling that bounds work handed to `ctx.waitUntil()`. Compare CPU time, and refer to Limits.