This feature requires{" "}
{v.name} version {v.version}
{getBoundText(v.bound)}.
)}
;
};
This documentation outlines how to configure logging with the AppSignal for Java integration.
## Configure Logging
🔐 Do not send Personal Identifiable Information (PII) to AppSignal. Filter PII (e.g., names, emails) from logs and use an ID, hash, or pseudonymized identifier instead.
For **HIPAA-covered entities**, more information about signing a Business Associate Agreement (BAA) can be found in our [Business Add-Ons documentation](/support/business-add-ons).
You do not need to create a log source to send logs from the AppSignal for Java integration. An "application" log source will be created automatically.
The Java integration uses OpenTelemetry's logging capabilities to send logs to AppSignal.
### Stand-alone usage
To use logging with OpenTelemetry in Java, you need to set up the logger using the OpenTelemetry LoggerProvider.
```java Java theme={null}
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.api.logs.Severity;
public class MyApplication {
public void logMessages() {
// Get the logger from the global logger provider
LoggerProvider loggerProvider = GlobalOpenTelemetry.getLoggerProvider();
Logger logger = loggerProvider.get("my-app");
// Log a message
logger.logRecordBuilder()
.setSeverity(Severity.INFO)
.setBody("Log message line")
.emit();
}
}
```
### Usage with Log4j
Log4j is automatically instrumented by the OpenTelemetry Java agent. Logs emitted using Log4j2
will automatically be sent to AppSignal.
Context added using `ThreadContext` or within `StructuredDataMessage` logs will be shown as
log tags in AppSignal.
```java Java theme={null}
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.ThreadContext;
import org.apache.logging.log4j.message.StructuredDataMessage;
public class MyService {
private static final Logger logger = LogManager.getLogger(MyService.class);
public void processOrder(String orderId) {
// This will be shown as a tag in AppSignal for all log lines
ThreadContext.put("order_id", orderId);
logger.info("Processing order");
StructuredDataMessage structuredMessage = new StructuredDataMessage(
"processing_items", // ID (not shown in AppSignal)
String.format("Processing items in order"), // Message
"order" // Type (not shown in AppSignal)
);
// This will be shown as a tag in AppSignal for this log line
structuredMessage.put("item_count", 123);
logger.info(structuredMessage);
ThreadContext.clearAll();
}
}
```
### Usage with `java.util.logging`
Java's built-in logging framework, `java.util.logging`, is automatically instrumented by the
OpenTelemetry Java agent. Logs emitted using `java.util.logging` will automatically be sent to
AppSignal.
```java Java theme={null}
import java.util.logging.Logger;
import java.util.logging.Level;
public class MyApplication {
private static final Logger logger = Logger.getLogger(MyApplication.class.getName());
public void doSomething() {
logger.info("Application started");
logger.log(Level.WARNING, "This is a warning message");
logger.severe("This is an error message");
}
}
```
## Usage
### Sending Logs
Using the OpenTelemetry logger directly, you can define the severity level of your logs:
```java Java theme={null}
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.api.logs.Severity;
public class MyApplication {
public void sendLogs() {
// Get the logger from the global logger provider
LoggerProvider loggerProvider = GlobalOpenTelemetry.getLoggerProvider();
Logger logger = loggerProvider.get("my-app");
// Different severity levels
logger.logRecordBuilder()
.setSeverity(Severity.WARN)
.setBody("Something went wrong")
.emit();
logger.logRecordBuilder()
.setSeverity(Severity.INFO)
.setBody("Action completed successfully")
.emit();
logger.logRecordBuilder()
.setSeverity(Severity.ERROR)
.setBody("Database connection failed")
.emit();
}
}
```
You can define custom attributes to send log information that can be used when filtering and querying logs:
```java Java theme={null}
import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.common.AttributeKey;
import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.api.logs.Logger;
import io.opentelemetry.api.logs.LoggerProvider;
import io.opentelemetry.api.logs.Severity;
public class InvoiceService {
public void generateInvoice(Customer customer) {
LoggerProvider loggerProvider = GlobalOpenTelemetry.getLoggerProvider();
Logger logger = loggerProvider.get("invoice_helper");
logger.logRecordBuilder()
.setSeverity(Severity.INFO)
.setBody("Generating invoice for customer")
.setAllAttributes(Attributes.of(
AttributeKey.stringKey("customer_id"), customer.getId()
))
.emit();
}
}
```
You can query and filter on message contents and attribute values from within the [Log Management](/logging/log-management) tool.
Once configured, the desired attributes will be sent to AppSignal as log tags, and be queryable in the AppSignal logging interface.
## Filtering Logs
You can use [the `ignore_logs` configuration option](/java/configuration#option-ignore_logs) to ignore log lines. See [our Ignore Logs guide](/guides/filter-data/ignore-logs) to learn more.
## Need Help?
After configuring your Java application to send logs, logs should appear in AppSignal. If you are unsure about this step or AppSignal is not receiving any logs, you can always [reach out](mailto:support@appsignal.com) for assistance. We'll help get you back on track!