# node:process

O módulo `node:process` fornece `process`, o objeto do Node.js que guarda informações sobre o processo atual e controla a execução dele. Em uma function, os usos mais frequentes são ler variáveis de ambiente por meio de `process.env` e agendar trabalho com `process.nextTick()`. Após o deploy, `process.env` contém as variáveis de ambiente da sua conta, que você também pode ler com `Azion.env.get()`.

No Azion Runtime, `process` também é um global, mas o global e o export padrão de `node:process` são objetos diferentes. Nos exemplos abaixo, o global `process.env.NODE_ENV` retorna `production`, e a mesma propriedade do objeto importado não retorna nenhum valor.

> **nota**
>
> Com `azion dev`, os callbacks de `nextTick` do exemplo de execução adiada são executados antes de `End`, e a resposta lista os dois. Sem um arquivo `.env` no projeto, `process.env` contém todo o ambiente de shell da máquina que executa `azion dev`.

---

## Exemplos

Cada exemplo é uma function completa que importa de `node:process`. A resposta abaixo de cada exemplo é a que uma function com deploy feito retorna.

### Variáveis de ambiente e nextTick

Esta function registra no log o global `process.env.NODE_ENV`, agenda um callback com `nextTick` e retorna o valor na resposta:

```javascript
/**
 * An example of using the Node.js Process API in an Azion Function.
 * Support:
 *  - Extended by library `process`
 *    Portions of this file Copyright Roman Shtylman, licensed under the MIT license.
 * @module runtime-apis/nodejs/process/main
 * @example
 * // Build and run with the Azion CLI:
 * azion build
 * azion dev
 */
import { env, nextTick } from "node:process";

/**
 * Example of using the process api
 * @param {*} event
 */
const main = async (event) => {
  console.log(process.env.NODE_ENV);

  nextTick(() => {
    console.log("Hello, Next Tick!");
    // Deployed, this line was not logged before the response was sent
  });

  return new Response(`NODE_ENV: ${process.env.NODE_ENV}`, { status: 200 });
};

export default main;
```

A function registra `production` no log e responde com este corpo:

```text
NODE_ENV: production
```

### Configuração a partir de variáveis de ambiente

Esta function lê quatro valores de configuração de `process.env`, usa um valor padrão para cada um deles e informa se uma chave de API está definida sem expor o valor dela:

```javascript
import process from "node:process";

const main = async (event) => {
  // Read environment variables
  const nodeEnv = process.env.NODE_ENV || "development";
  const apiKey = process.env.API_KEY;
  const debug = process.env.DEBUG === "true";
  const maxRetries = parseInt(process.env.MAX_RETRIES || "3", 10);

  console.log("Environment:", nodeEnv);
  console.log("Debug mode:", debug);
  console.log("Max retries:", maxRetries);

  // Check if required variables are set
  if (!apiKey) {
    console.warn("API_KEY not configured");
  }

  // Build configuration object
  // Security: Never expose sensitive env vars in responses
  // Use boolean flags instead of actual values
  const config = {
    environment: nodeEnv,
    debug,
    maxRetries,
    hasApiKey: !!apiKey  // Boolean only, not the actual key
  };

  return new Response(JSON.stringify(config), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

Sem nenhuma das quatro variáveis definidas, a function registra o aviso `API_KEY not configured` no log e responde com os valores padrão:

```json
{"environment":"development","debug":false,"maxRetries":3,"hasApiKey":false}
```

### Execução adiada com nextTick

Esta function registra a ordem em que o código dela é executado em torno de duas chamadas a `nextTick`, aguarda 10 ms e retorna essa ordem:

```javascript
import { nextTick } from "node:process";
import { setTimeout } from "node:timers/promises";

const main = async (event) => {
  const executionOrder = [];

  executionOrder.push("Start");

  // Schedule with nextTick - runs after the current code
  // Deployed, the callbacks have not run when the response is built
  nextTick(() => {
    executionOrder.push("NextTick callback");
    console.log("Deferred execution completed");
  });

  executionOrder.push("After nextTick call");

  // Schedule a second callback
  nextTick(() => {
    executionOrder.push("Second nextTick");
  });

  // Wait 10 ms before building the response
  await setTimeout(10);

  executionOrder.push("End");

  console.log("Execution order:", executionOrder.join(" -> "));

  return new Response(JSON.stringify({ executionOrder }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

Em uma function com deploy feito, os callbacks de `nextTick` ainda não foram executados quando a function monta a resposta, então a ordem termina em `End` e não lista nenhum dos callbacks:

```json
{"executionOrder":["Start","After nextTick call","End"]}
```

### Informações do processo

Esta function lê a plataforma, a arquitetura, as versões e os IDs de processo, e os retorna como JSON formatado:

```javascript
import process from "node:process";

const main = async (event) => {
  // In Azion Runtime, these process properties return fixed values:
  // - process.platform and process.arch are empty strings
  // - process.pid is 200 and process.ppid is 100
  // - process.versions holds only the node field

  // Platform information
  const platform = process.platform;
  const arch = process.arch;
  const versions = process.versions;

  // Process identification
  const pid = process.pid;
  const ppid = process.ppid;

  // Runtime information
  const nodeVersion = process.version;
  const v8Version = versions.v8;

  console.log("Platform:", platform);
  console.log("Architecture:", arch);
  console.log("Node version:", nodeVersion);
  console.log("V8 version:", v8Version);
  console.log("Process ID:", pid);

  // Build info object with fallbacks for potentially undefined values
  const processInfo = {
    platform,
    arch,
    pid,
    ppid,
    nodeVersion,
    v8Version,
    versions: {
      node: versions.node || "unknown",
      v8: versions.v8 || "unknown",
      openssl: versions.openssl || "unknown"
    }
  };

  return new Response(JSON.stringify(processInfo, null, 2), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

A function responde com os valores fixos. `v8Version` é indefinido, então `JSON.stringify` o deixa fora do corpo:

```json
{
  "platform": "",
  "arch": "",
  "pid": 200,
  "ppid": 100,
  "nodeVersion": "v22.14.0",
  "versions": {
    "node": "22.14.0",
    "v8": "unknown",
    "openssl": "unknown"
  }
}
```

### Uso de memória

Esta function lê `process.memoryUsage()` antes e depois de montar um array, e retorna as duas leituras e a diferença entre elas:

```javascript
import process from "node:process";

const main = async (event) => {
  // Get initial memory usage
  const initialMemory = process.memoryUsage();

  // Simulate some work
  const data = [];
  for (let i = 0; i < 1000; i++) {
    data.push({ id: i, data: "x".repeat(100) });
  }

  // Get memory usage after work
  const finalMemory = process.memoryUsage();

  // Calculate memory delta
  const memoryDelta = {
    rss: finalMemory.rss - initialMemory.rss,
    heapTotal: finalMemory.heapTotal - initialMemory.heapTotal,
    heapUsed: finalMemory.heapUsed - initialMemory.heapUsed,
    external: finalMemory.external - initialMemory.external
  };

  console.log("Initial heap used:", initialMemory.heapUsed, "bytes");
  console.log("Final heap used:", finalMemory.heapUsed, "bytes");
  console.log("Memory delta:", memoryDelta.heapUsed, "bytes");

  return new Response(JSON.stringify({
    initial: {
      rss: initialMemory.rss,
      heapTotal: initialMemory.heapTotal,
      heapUsed: initialMemory.heapUsed
    },
    final: {
      rss: finalMemory.rss,
      heapTotal: finalMemory.heapTotal,
      heapUsed: finalMemory.heapUsed
    },
    delta: memoryDelta
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

Todos os campos de `process.memoryUsage()` retornam `0`, então as duas leituras e a diferença são `0`:

```json
{"initial":{"rss":0,"heapTotal":0,"heapUsed":0},"final":{"rss":0,"heapTotal":0,"heapUsed":0},"delta":{"rss":0,"heapTotal":0,"heapUsed":0,"external":0}}
```

### Uptime e medição de tempo

Esta function lê `process.uptime()` e `process.hrtime()` e, em seguida, mede uma espera de 100 ms com `process.hrtime.bigint()`:

```javascript
import process from "node:process";
import { setTimeout } from "node:timers/promises";

const main = async (event) => {
  // Get process uptime in seconds
  const uptime = process.uptime();

  // Get high-resolution time
  const hrtime = process.hrtime();
  const hrtimeBigint = process.hrtime.bigint();

  console.log("Process uptime:", uptime, "seconds");
  console.log("High-res time:", hrtime);
  console.log("High-res time (bigint):", hrtimeBigint.toString(), "nanoseconds");

  // Measure an operation; deployed, the measured time is 0
  const start = process.hrtime.bigint();

  // Simulate work
  await setTimeout(100);

  const end = process.hrtime.bigint();
  const elapsedNs = Number(end - start);
  const elapsedMs = elapsedNs / 1_000_000;

  console.log("Operation took:", elapsedMs.toFixed(2), "ms");

  return new Response(JSON.stringify({
    uptime: {
      seconds: uptime,
      formatted: formatUptime(uptime)
    },
    hrtime: {
      seconds: hrtime[0],
      nanoseconds: hrtime[1]
    },
    operationTime: {
      nanoseconds: elapsedNs,
      milliseconds: elapsedMs
    }
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

// Helper function defined before export
function formatUptime(seconds) {
  const hours = Math.floor(seconds / 3600);
  const minutes = Math.floor((seconds % 3600) / 60);
  const secs = Math.floor(seconds % 60);
  return `${hours}h ${minutes}m ${secs}s`;
}

export default main;
```

Após o deploy, `process.uptime()` retorna `0`, `process.hrtime()` retorna segundos inteiros com `0` nanossegundos, e o tempo medido durante a espera de 100 ms é `0`:

```json
{"uptime":{"seconds":0,"formatted":"0h 0m 0s"},"hrtime":{"seconds":1767268800,"nanoseconds":0},"operationTime":{"nanoseconds":0,"milliseconds":0}}
```

---

## APIs suportadas

A tabela lista o status de cada API de `node:process` no Azion Runtime:

| API                       | Status                              |
| ------------------------- | ----------------------------------- |
| `process.env`             | 🟢 Com suporte                      |
| `process.nextTick()`      | 🟢 Com suporte                      |
| `process.platform`        | 🟡 Suporte parcial (string vazia)   |
| `process.arch`            | 🟡 Suporte parcial (string vazia)   |
| `process.version`         | 🟢 Com suporte                      |
| `process.versions`        | 🟡 Suporte parcial (somente `node`) |
| `process.pid`             | 🟡 Suporte parcial (valor fixo)     |
| `process.ppid`            | 🟡 Suporte parcial (valor fixo)     |
| `process.uptime()`        | 🟡 Suporte parcial (retorna `0`)    |
| `process.hrtime()`        | 🟡 Suporte parcial                  |
| `process.hrtime.bigint()` | 🟡 Suporte parcial                  |
| `process.memoryUsage()`   | 🟡 Suporte parcial (retorna `0`)    |
| `process.cwd()`           | 🟡 Suporte parcial                  |
| `process.exit()`          | 🟡 Suporte parcial                  |
| `process.on()`            | 🟡 Suporte parcial                  |
| `process.argv`            | 🟡 Suporte parcial                  |
| `process.title`           | 🟡 Suporte parcial                  |
| `process.binding()`       | 🔴 Sem suporte                      |

As APIs marcadas como 🟡 Suporte parcial têm funcionalidade limitada em comparação com a implementação completa do Node.js. Os valores delas são fixos e não descrevem a máquina que executa o seu código. `process.platform`, `process.arch` e `process.title` são strings vazias, `process.pid` é `200` e `process.ppid` é `100`. `process.version` é `v22.14.0`, e `process.versions` contém somente `node`. `process.cwd()` retorna `/`, e `process.argv` é um array vazio. Após o deploy, `process.hrtime()` e `process.hrtime.bigint()` retornam segundos inteiros com `0` nanossegundos.

`process.exit()` não encerra o processo do runtime, e `process.on()` tem suporte limitado a eventos. `process.binding()` lança `Error: [unenv] process.binding is not implemented yet!`. Para a configuração do ambiente, use `process.env`, que tem suporte completo.

---

## Recursos relacionados

- [APIs do Node.js](/pt-br/documentacao/devtools/runtime/node.md): O status de cada módulo do Node.js no Azion Runtime, incluindo `process`.
- [API de variáveis de ambiente](/pt-br/documentacao/devtools/runtime/api-reference/environment-variables.md): Como uma function lê as variáveis de ambiente da sua conta com `Azion.env.get()`.
- [node:os](/pt-br/documentacao/devtools/runtime/node/os.md): O módulo os, cujas funções também retornam valores fixos dentro de uma function.
- [Documentação de process do Node.js](https://nodejs.org/api/process.html): A referência completa do Node.js para cada API de `node:process` da tabela.