# Report runtime function errors (1st gen)

You should handle and report runtime errors that occur in Cloud Run functions.
Uncaught exceptions or executions that crash the process can result in
[cold starts](https://docs.cloud.google.com/functions/1stgendocs/concepts/execution-environment.md.txt#cold-starts),
which you should generally try to minimize.

The recommended way for a function to signal an error depends on the function
type:

- HTTP functions should return appropriate HTTP status codes which denote an
  error. See [HTTP Functions](https://docs.cloud.google.com/functions/1stgendocs/writing/write-http-functions.md.txt)
  for more information.

- Event-driven functions should log and return an error message. See
  [Write event-driven functions](https://docs.cloud.google.com/functions/1stgendocs/writing/write-event-driven-functions.md.txt)
  for more information.

If errors are appropriately handled, then function instances that encounter
errors can remain active and available to serve requests.

## Emit errors to Error Reporting

You can emit an error from a Cloud Run function to
[Error Reporting](https://cloud.google.com/error-reporting/docs) as shown in the following:

### Node.js

```javascript
// These WILL be reported to Error Reporting
throw new Error('I failed you'); // Will cause a cold start if not caught
```

### Python

```python
@functions_framework.http
def hello_error_1(request):
    # This WILL be reported to Error Reporting,
    # and WILL NOT show up in logs or
    # terminate the function.
    from google.cloud import error_reporting

    client = error_reporting.Client()

    try:
        raise RuntimeError("I failed you")
    except RuntimeError:
        client.report_exception()

    # This WILL be reported to Error Reporting,
    # and WILL terminate the function
    raise RuntimeError("I failed you")


@functions_framework.http
def hello_error_2(request):
    # These errors WILL NOT be reported to Error
    # Reporting, but will show up in logs.
    import logging
    import sys

    print(RuntimeError("I failed you (print to stdout)"))
    logging.warning(RuntimeError("I failed you (logging.warning)"))
    logging.error(RuntimeError("I failed you (logging.error)"))
    sys.stderr.write("I failed you (sys.stderr.write)\n")

    # This is considered a successful execution and WILL NOT be reported
    # to Error Reporting, but the status code (500) WILL be logged.
    from flask import abort

    return abort(500)

```

### Go

```go

package tips

import (
	"fmt"
	"net/http"
	"os"

	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
)

func init() {
	functions.HTTP("HTTPError", HTTPError)
}

// HTTPError describes how errors are handled in an HTTP function.
func HTTPError(w http.ResponseWriter, r *http.Request) {
	// An error response code is NOT reported to Error Reporting.
	// http.Error(w, "An error occurred", http.StatusInternalServerError)

	// Printing to stdout and stderr is NOT reported to Error Reporting.
	fmt.Println("An error occurred (stdout)")
	fmt.Fprintln(os.Stderr, "An error occurred (stderr)")

	// Calling log.Fatal sets a non-zero exit code and is NOT reported to Error
	// Reporting.
	// log.Fatal("An error occurred (log.Fatal)")

	// Panics are reported to Error Reporting.
	panic("An error occurred (panic)")
}
```

### Java

```java

import com.google.cloud.functions.HttpFunction;
import com.google.cloud.functions.HttpRequest;
import com.google.cloud.functions.HttpResponse;
import java.io.IOException;
import java.util.logging.Logger;

public class HelloError implements HttpFunction {

  private static final Logger logger = Logger.getLogger(HelloError.class.getName());

  @Override
  public void service(HttpRequest request, HttpResponse response)
      throws IOException {
    // These will NOT be reported to Error Reporting
    System.err.println("I failed you");
    logger.severe("I failed you");

    // This WILL be reported to Error Reporting
    throw new RuntimeException("I failed you");
  }
}
```

If you would like more fine-grained error reporting, you can use the [Error
Reporting client
libraries](https://docs.cloud.google.com/error-reporting/docs/reference/libraries).

You can view the reported errors in [Error Reporting](https://console.cloud.google.com/errors)
in the Google Cloud console. You can also see the errors reported from a
particular function when you select it from the [list of functions](https://console.cloud.google.com/functions) in the Google Cloud console.

Uncaught exceptions produced by your function will appear in Error Reporting.
Note that some types of uncaught exceptions (such as those thrown
asynchronously) will cause a [cold
start](https://docs.cloud.google.com/functions/1stgendocs/concepts/execution-environment#cold-starts) to occur upon
a future function invocation. This increases the amount of time your function
will take to run.