Interactive Debugging

Workflow failures can be both frustrating and lead to wasted resources as the team seeks to understand what went wrong and why. Dagger's interactive debugging feature is an invaluable tool in this situation.

Dagger lets users drop in to an interactive shell when a workflow run fails, with all the context at the point of failure. This is similar to a debugger experience, but without needing to set breakpoints explicitly. No changes are required to your code.

Here's an example of a workflow run failing, and Dagger opening an interactive terminal at the point of failure:

Go

package main

import "context"

type MyModule struct{}

func (m *MyModule) Foo(ctx context.Context) (string, error) {
	return dag.Container().
		From("alpine:latest").
		WithExec([]string{"sh", "-c", "echo hello world > /foo"}).
		WithExec([]string{"cat", "/FOO"}). // deliberate error
		Stdout(ctx)
}

// run with dagger call --interactive foo

Python

from dagger import dag, function, object_type


@object_type
class MyModule:
    @function
    async def foo(self) -> str:
        return await (
            dag.container()
            .from_("alpine:latest")
            .with_exec(["sh", "-c", "echo hello world > /foo"])
            .with_exec(["cat", "/FOO"])  # deliberate error
            .stdout()
        )


# run with dagger call --interactive foo

TypeScript

import { dag, object, Directory, Container, func } from "@dagger.io/dagger"

@object()
class MyModule {
  @func()
  async foo(): Promise<string> {
    return await dag
      .container()
      .from("alpine:latest")
      .withExec(["sh", "-c", "echo hello world > /foo"])
      .withExec(["cat", "/FOO"]) // deliberate error
      .stdout()
  }
}

// run with dagger call --interactive foo

PHP

<?php

declare(strict_types=1);

namespace DaggerModule;

use Dagger\Attribute\{DaggerObject, DaggerFunction};

use function Dagger\dag;

#[DaggerObject]
class MyModule
{
    #[DaggerFunction]
    public function foo(): string
    {
        return dag()
            ->container()
            ->from('alpine:latest')
            ->withExec(['sh', '-c', 'echo hello world > /foo'])
            ->withExec(['cat', '/FOO']) // deliberate error
            ->stdout();
    }
}

Java

package io.dagger.modules.mymodule;

import static io.dagger.client.Dagger.dag;

import io.dagger.client.DaggerQueryException;
import io.dagger.module.annotation.Function;
import io.dagger.module.annotation.Object;
import java.util.List;
import java.util.concurrent.ExecutionException;

@Object
public class MyModule {
  @Function
  public String foo() throws ExecutionException, DaggerQueryException, InterruptedException {
    return dag().container()
        .from("alpine:latest")
        .withExec(List.of("sh", "-c", "echo hello world > /foo"))
        .withExec(List.of("cat", "/FOO")) // deliberate error
        .stdout();
  }
}

// run with dagger call --interactive foo

See it in action:

You can also set one or more explicit breakpoints in your workflow, which then starts an interactive terminal session at each breakpoint. This lets you inspect a directory or a container at any point in your workflow run, with all the necessary context available to you.

Here's another example, which opens an interactive terminal at two different points in a workflow run to inspect the built container:

Go

package main

import (
	"context"
	"dagger/my-module/internal/dagger"
)

type MyModule struct{}

func (m *MyModule) Foo(ctx context.Context) *dagger.Container {
	return dag.Container().
		From("alpine:latest").
		Terminal().
		WithExec([]string{"sh", "-c", "echo hello world > /foo"}).
		Terminal()
}

Python

import dagger
from dagger import dag, function, object_type


@object_type
class MyModule:
    @function
    async def foo(self) -> dagger.Container:
        return await (
            dag.container()
            .from_("alpine:latest")
            .terminal()
            .with_exec(["sh", "-c", "echo hello world > /foo"])
            .terminal()
        )

TypeScript

import { dag, object, Directory, Container, func } from "@dagger.io/dagger"

@object()
class MyModule {
  @func()
  async foo(): Container {
    return await dag
      .container()
      .from("alpine:latest")
      .terminal()
      .withExec(["sh", "-c", "echo hello world > /foo"])
      .terminal()
  }
}

PHP

<?php

declare(strict_types=1);

namespace DaggerModule;

use Dagger\Attribute\{DaggerObject, DaggerFunction};
use Dagger\Container;

use function Dagger\dag;

#[DaggerObject]
class MyModule
{
    #[DaggerFunction]
    public function foo(): Container
    {
        return dag()
            ->container()
            ->from('alpine:latest')
            ->terminal()
            ->withExec(["sh", "-c", "echo hello world > /foo"])
            ->terminal();
    }
}

Java

package io.dagger.modules.mymodule;

import static io.dagger.client.Dagger.dag;

import io.dagger.client.Container;
import io.dagger.module.annotation.Function;
import io.dagger.module.annotation.Object;
import java.util.List;

@Object
public class MyModule {
  @Function
  public Container foo() {
    return dag().container()
        .from("alpine:latest")
        .terminal()
        .withExec(List.of("sh", "-c", "echo hello world > /foo"))
        .terminal();
  }
}

See it in action:

Learn more

• Debug with the interactive terminal