> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Disable tracing

> Learn options to disable or conditionally turn off W&B Weave tracing

There are different options available to control the level of Weave tracing in your application, depending on your environment and needs.

## Environment variable

In situations where you want to unconditionally disable tracing for the entire program, you can set the environment variable `WEAVE_DISABLED=true`.

`WEAVE_DISABLED` is read only once, at function-definition time. This variable cannot be used to toggle tracing at runtime.

## Client initialization

Sometimes, you may want to conditionally enable tracing for a specific initialization based on some condition. In this case, you can initialize the client with the `disabled` flag in init settings.

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    import weave

    # Initialize the client
    client = weave.init(..., settings={"disabled": True})
    ```
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={null}
    This feature is not available for the TypeScript SDK yet.
    ```
  </Tab>
</Tabs>

## Context manager

To conditionally disable tracing for a specific block of code, you can use a tracing context manager. Use `with tracing_disabled()` to suppress tracing **only for the function calls executed inside the `with` block**. Use it in application code to scope which calls should not be logged.

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    import weave
    from weave.trace.context.call_context import tracing_disabled

    client = weave.init('your-team/your-project-name')

    @weave.op
    def my_op():
        ...

    with tracing_disabled():
        my_op()
    ```
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={null}
    This feature is not available for the TypeScript SDK yet.
    ```
  </Tab>
</Tabs>

Although tracing behavior is fixed when functions are defined, this can be used for runtime control when combined with application logic. For example, you can wrap the context manager in a conditional to dynamically enable or disable tracing based on a runtime value:

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    if should_trace:
        my_op()
    else:
        with tracing_disabled():
            my_op()
    ```
  </Tab>

  <Tab title="TypeScript">
    ```plaintext theme={null}
    This feature is not available for the TypeScript SDK yet.
    ```
  </Tab>
</Tabs>