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

# Limits and expected behaviors

> A list of Weave's limitations, known issues, and expected behaviors

Weave has the following limitations, known issues, and expected behaviors. Use this list as a reference when you encounter unexpected results or want to understand how Weave handles edge cases.

* For retryable requests, Weave retries requests starting at 1 second after receiving the first error and then doubles the amount of time between attempts up to 5 minutes. Requests time out after 36 hours.

* Instead of raising exceptions, [`.call()`](https://docs.coreweave.com/products/wandb/weave/guides/tracking/tracing#creating-calls) captures exceptions and stores them in the `call.exception`. If you need to raise exceptions during execution, set the [`__should_raise` parameter](https://docs.coreweave.com/products/wandb/weave/reference/python-sdk/trace/op#function-call), like this:

  ```python showLineNumbers theme={"system"}
  # This raises exceptions
  result, call = foo.call(__should_raise=True)
  ```

* Object names, tags, and aliases have length and character rules, and the Python SDK rewrites object names that break them. Op names and Call display names have length limits. For details, see [Naming rules](https://docs.coreweave.com/products/wandb/weave/guides/tracking/objects.md#naming-rules) and [Name length limits](https://docs.coreweave.com/products/wandb/weave/guides/tracking/set-call-display.md#name-length-limits).

* Dedicated Weave instances use a different OpenTelemetry ingress URL. For more information about authoritative endpoints, see [Send OpenTelemetry traces](https://docs.coreweave.com/products/wandb/weave/guides/tracking/otel.md).

* Weave sometimes truncates large trace data objects. This occurs because the default trace output is a raw, custom Python object that Weave can't serialize automatically. To return all of your trace data, define a dictionary of strings, like this:

  ```python theme={"system"}
  import weave

  class MyObj:
      """An object with a large string attribute."""
      def __init__(self, x: int):
          self.x = x

      def __repr__(self):
          return f"MyObj(x={self.x})"

      def to_dict(self):
          return {"x": self.x}

  @weave.op()
  def make_my_obj():
      x = "a" * 10_000
      return MyObj(x)

  def main():
      weave.init("<entity/project>")

      # Define a traceable operation that processes MyObj
      @weave.op()
      def process_obj(obj: MyObj) -> int:
          return len(obj.x)

      # Create and process a large MyObj instance
      large_obj = make_my_obj()
      length = process_obj(large_obj)
      print(f"Length of x in MyObj: {length}")
      print("dict:", large_obj.to_dict())

  if __name__ == "__main__":
      main()
  ```
