# Migrating from Lumigo to Ivy

Moving Lambda tracing from Lumigo to Ivy takes a few minutes per AWS account. You stop Lumigo's tracing (its layer, its wrapper and its token variable), connect the account to Ivy, and pick which functions to trace. Your coding agent can do most of it. Lumigo has announced that its platform shuts down on December 31, 2026, so plan the switch before then.

## Before you start

- **Check what Ivy supports.** Ivy's layer instruments **Node.js** functions today. If you also trace Python, Java or Go functions with Lumigo, those need another tool for now, or an OpenTelemetry SDK that sends OTLP to Ivy.
- **Find out how Lumigo was attached.** Either Lumigo's **auto-trace** added its layer (from the Lumigo UI or the `lumigo:auto-trace` tag), or your **infrastructure code** adds it (CDK, Serverless Framework, SAM, Terraform and so on). The steps differ slightly.
- **Export what you want to keep.** Ivy does not import Lumigo's historical data. Note your alert rules and any dashboards you rely on.

## Step 1: Stop Lumigo's tracing

Ivy and Lumigo both use `AWS_LAMBDA_EXEC_WRAPPER`, and a function can only have one, so remove Lumigo's before adding Ivy's.

**If Lumigo's auto-trace attached it:** untrace the functions in the Lumigo UI, or set the tag `lumigo:auto-trace` to `false` on them (Lumigo's docs say changes take 15 to 20 minutes). Then check one function's configuration to confirm the Lumigo layer and variables are gone.

**If your infrastructure code adds it,** remove from each function:

| Remove | What it is |
|---|---|
| The `lumigo-node-tracer` layer | Lumigo's Node.js tracer layer (its ARN names the region and version) |
| `AWS_LAMBDA_EXEC_WRAPPER=/opt/lumigo_wrapper` | Lumigo's exec wrapper |
| `LUMIGO_TRACER_TOKEN` | Your Lumigo token |
| `LUMIGO_ORIGINAL_HANDLER` | Only if you used handler redirection: set the function's handler back to this value |
| Any other `LUMIGO_*` variables | Optional tracer settings |
| `@lumigo/tracer` imports and `lumigo.trace(...)` wrappers | Only if you wrapped handlers in code |

These names come from [Lumigo's layer documentation](https://docs.lumigo.io/docs/lambda-layers); check them against your own configuration. Lumigo's CDK constructs and Serverless plugin add the same pieces, so removing the construct or plugin is usually enough.

## Step 2: Connect Ivy

**The quick way:** paste this into your coding agent in the repository that deploys your functions.

```
Set up Ivy for my AWS Lambda functions using https://ivytrace.dev/llms.txt
```

The agent signs you up (you approve in your browser), creates a workspace and project, and gives you a CloudFormation quick-create link that creates Ivy's role in your AWS account. Then it lists your functions grouped by CloudFormation stack and asks which to trace. If it finds infrastructure code that sets layers or environment variables, it offers to add Ivy there instead, so the next deploy doesn't remove it. You can also tell it: *"We're moving off Lumigo: remove the Lumigo layer and variables first."*

**By hand:** connect the account in the dashboard (Workspace settings → AWS accounts), or add the layer yourself:

| Add | Value |
|---|---|
| Layer | `ivy-trace-nodejs`, published in your own account by Ivy |
| `AWS_LAMBDA_EXEC_WRAPPER` | `/opt/ivy-wrapper` |
| `IVY_ENDPOINT` | Your ingest endpoint |
| `IVY_API_KEY` | A project ingest key |

Details in [manual setup](https://ivytrace.dev/docs/manual-setup).

## Step 3: Choose what to trace

Ivy's auto-trace is **opt-in**, like a Lumigo auto-trace selection, but saved as rules:

- a whole **CloudFormation stack** (`{"stack": "checkout-prod"}`),
- a **name pattern** (`{"name": "checkout-*"}`),
- or a **tag** (`{"tag": "team=core"}`).

New functions that match a rule are traced automatically. The tag `ivy:trace=true` or `false` on a function overrides rules, much like `lumigo:auto-trace`.

## Step 4: Verify

Invoke one function, or wait for traffic, and open **Invocations** in Ivy. The trace should show the event, the response and the AWS calls. Ask your agent to *"find failing invocations in the last hour"* to check the MCP connection.

## Step 5: Set up alerts

Connect Slack (**Add to Slack**, then pick a channel) to get a message when an error group is first seen. The weekly email digest is on for workspace members by default. See [setting up alerts](https://ivytrace.dev/docs/alerts).

## Concept map

| Lumigo | Ivy |
|---|---|
| Transaction | Trace: one Lambda invocation with all its spans |
| Invocation | Invocation (the trace's root span) |
| Issue | Error group, fingerprinted by function, error type and message |
| Alert | Slack alert per error group, plus the weekly email digest |
| Project | Workspace (team, billing, AWS accounts) and project (one app or environment) |
| Auto-trace and `lumigo:auto-trace` tag | Auto-trace rules and the `ivy:trace` tag |
| `LUMIGO_TRACER_TOKEN` | `IVY_API_KEY` (a project ingest key) |
| Lumigo Copilot | Your coding agent with Ivy's MCP server |
| Timeouts and out of memory | Failures outside the handler: init errors, OOM, crashes, timeouts, throttles |

## What's different

- **Alerting is simpler.** Ivy alerts on error groups in Slack and sends a weekly digest. There are no metric alerts, custom rules beyond the thresholds, or PagerDuty integration.
- **No log management.** Ivy keeps each invocation's `console.*` lines and the last log lines of failures, not all of your logs.
- **Node.js only** for the layer, today.
- **Payload redaction runs in the function.** Ivy redacts keys like `authorization`, `password` and `token` by default. Add your own with `IVY_REDACT_KEYS`.
- **Pricing.** €5 per million traces after 100,000 free a month per workspace, or self-host for free. See [pricing](https://ivytrace.dev/pricing).

## Frequently asked questions

### Can I run Lumigo and Ivy side by side?

Not on the same function: both rely on `AWS_LAMBDA_EXEC_WRAPPER`, and only one wrapper can be set. You can move functions over stack by stack, keeping Lumigo on the rest until you're done.

### Will removing Lumigo's layer change my function's behaviour?

It shouldn't. If you used Lumigo's handler redirection, set the handler back to the value of `LUMIGO_ORIGINAL_HANDLER` before removing that variable, or the function will fail to start (Ivy would show it as an init error).

### Can Ivy import my Lumigo history?

No. Ivy starts from the first trace after you switch. Keep exports of anything you need from Lumigo before December 31, 2026.

### Is Dash0 the better choice for Lumigo users?

It depends on what you need. Dash0 is Lumigo's official successor and a broad observability platform. Ivy is smaller, focused on Lambda, open source, and priced per invocation. See [Ivy vs Lumigo](https://ivytrace.dev/compare/lumigo).

---

Source: https://ivytrace.dev/migrate/lumigo · Updated 2026-11-14