## Overview **Programmatic Errors** allow you to customize errors, monitor and troubleshoot issues that should not necessarily interfere with the service. For example, an application trying to remove a user who doesn't exist is such an error. These custom errors can be handled by adding just a few lines of code. ![](https://files.readme.io/1cc7954-programmatic_error_issue.png "programmatic error issue.png") **Programmatic Errors** are labelled as warnings to indicate that a non fatal error occurred, such as application error. You can log programmatic errors, track custom error issues, and trigger [Alerts](https://docs.lumigo.io/docs/event-alerts#/). # Lambda ## Configuring a Generic Error Programmatic Errors can be configured from anywhere within your Lambda handler’s code. Below are some examples using the [Lumigo tracer integrations](https://docs.lumigo.io/docs/manual-instrumentation). ```python Python print("[LUMIGO_LOG] ") ``` ```javascript NodeJS console.log("[LUMIGO_LOG] "); ``` ```java System.out.println("[LUMIGO_LOG] "); ``` ## Configuring a Custom Error To configure custom types of errors, use one of the three options listed below: 1. Lumigo tracer logger: ```python import lumigo_tracer lumigo_tracer.error("a description of the error", "My Custom Type") ``` ```javascript NodeJS const lumigo = require('@lumigo/tracer'); lumigo.error("a description of the error", { type: "My Custom Type" }); ``` 2. Logging with Lumigo format: ```python Python error = { 'message': 'a description of the error', 'type': 'My Custom Type' } print("[LUMIGO_LOG]", json.dumps(error)) ``` ```javascript NodeJS let error = { 'message': 'a description of the error', 'type': 'My Custom Type' }; console.log(`[LUMIGO_LOG] ${JSON.stringify(error)}`); ``` 3. Logging in pure JSON format: * For field 'message' you can alternatively use 'event'. * For field 'type' you can alternatively use 'exception\_name', 'exception\_type' ```python Python print(json.dumps({ 'message': '[LUMIGO_LOG] a description of the error', 'type': 'My Custom Type' })) ``` ```javascript NodeJS let error = { 'message': '[LUMIGO_LOG] a description of the error', 'type': 'My Custom Type' }; console.log(JSON.stringify(error)); ``` > 📘 > > Note that when configuring programmatic errors the `type` error field is case sensitive and length specific. For example, setting an error with the type “Error 42 “ will cause the associated errors to aggregate differently to “error 42” on the issues page. # OpenTelemetry and Containers Programmatic errors are created by adding span events with a custom attribute being set with the key name lumigo.type. For example, you could add a programmatic error as follows: ```python Python from opentelemetry.trace import get_current_span get_current_span().add_event('', {'lumigo.type': ''}) ``` ```javascript NodeJS const { trace } = require('@opentelemetry/api'); trace.getActiveSpan()?.addEvent('', {'lumigo.type': ''}); ``` ```Text Java Attributes eventAttributes = Attributes.of( AttributeKey.stringKey("lumigo.type"), "" ); Span.current().addEvent("", eventAttributes); ``` # Example A Twilio SMS API discards outgoing SMS requests that contain an empty message body, but does not return an error indication, this can be handled using programmatic errors. ![](https://files.readme.io/995b6f3-programmatic_error.png "programmatic error.png") Twilio returns multiple error messages for different cases. Since you may care more about some of these errors and less about others, looking at all of the errors through a single lens (for example, as generic 4xx or "client errors") could be very inefficient. You can use a custom programmatic error type for each of the cases. If we look at a 400 response returned from Twilio as part of the example: ```text Example - Twilio Error Handling { "code": 14108, "message": "Invalid Phone Number", "more_info": "https://www.twilio.com/docs/errors/14108", "status": 400 } ``` Then the code can use that to report Lumigo Programmatic Errors in the following way: ```python Example (Python) . . . response = twilio_client.messages.create(body=sms.message, from_=sms.sender, to=sms.recepient) if response.status == 400: if response.code == 14108: lumigo.error(response.message, 'Twilio: Invalid Phone Number') elif response.code == 32103: lumigo.error(response.message, 'Twilio: Empty SMS Body') . . . else: lumigo.error(response.message, 'Twilio: Client Error') . . . ``` Resulting in multiple issues grouped by issue type as defined from our code example above. {2644}