repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/accessemailwithimap/GmailApp.java | libraries-io/src/main/java/com/baeldung/java/io/accessemailwithimap/GmailApp.java | package com.baeldung.java.io.accessemailwithimap;
import jakarta.mail.Store;
import jakarta.mail.Folder;
import jakarta.mail.Message;
import jakarta.mail.MessagingException;
import jakarta.mail.Session;
import jakarta.mail.Flags;
import jakarta.mail.search.FlagTerm;
import jakarta.mail.search.FromStringTerm;
import jakarta.mail.search.SearchTerm;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.Arrays;
import java.util.Properties;
public class GmailApp {
private static final Logger LOGGER = LoggerFactory.getLogger(GmailApp.class);
public static Store establishConnection() throws MessagingException {
Properties props = System.getProperties();
props.setProperty("mail.store.protocol", "imaps");
Session session = Session.getDefaultInstance(props, null);
Store store = session.getStore("imaps");
store.connect("imap.googlemail.com", "EMAIL", "APP PASSWORD");
return store;
}
public static void emailCount(Store store) throws MessagingException {
Folder inbox = store.getFolder("inbox");
Folder spam = store.getFolder("[Gmail]/Spam");
inbox.open(Folder.READ_ONLY);
LOGGER.info("No of Messages : " + inbox.getMessageCount());
LOGGER.info("No of Unread Messages : " + inbox.getUnreadMessageCount());
LOGGER.info("No of Messages in spam : " + spam.getMessageCount());
LOGGER.info("No of Unread Messages in spam : " + spam.getUnreadMessageCount());
inbox.close(true);
}
public static void readEmails(Store store) throws MessagingException, IOException {
Folder inbox = store.getFolder("inbox");
inbox.open(Folder.READ_ONLY);
Message[] messages = inbox.getMessages();
if (messages.length > 0) {
Message message = messages[0];
LOGGER.info("Subject: " + message.getSubject());
LOGGER.info("From: " + Arrays.toString(message.getFrom()));
LOGGER.info("Text: " + message.getContent());
}
inbox.close(true);
}
public static void searchEmails(Store store, String from) throws MessagingException {
Folder inbox = store.getFolder("inbox");
inbox.open(Folder.READ_ONLY);
SearchTerm senderTerm = new FromStringTerm(from);
Message[] messages = inbox.search(senderTerm);
Message[] getFirstFiveEmails = Arrays.copyOfRange(messages, 0, 5);
for (Message message : getFirstFiveEmails) {
LOGGER.info("Subject: " + message.getSubject());
LOGGER.info("From: " + Arrays.toString(message.getFrom()));
}
inbox.close(true);
}
public static void deleteEmail(Store store) throws MessagingException {
Folder inbox = store.getFolder("inbox");
inbox.open(Folder.READ_WRITE);
Message[] messages = inbox.getMessages();
if (messages.length >= 7) {
Message seventhLatestMessage = messages[messages.length - 7];
seventhLatestMessage.setFlag(Flags.Flag.DELETED, true);
LOGGER.info("Delete the seventh message: " + seventhLatestMessage.getSubject());
} else {
LOGGER.info("There are less than seven messages in the inbox.");
}
inbox.close(true);
}
public static void markLatestUnreadAsRead(Store store) throws MessagingException {
Folder inbox = store.getFolder("inbox");
inbox.open(Folder.READ_WRITE);
Message[] messages = inbox.search(new FlagTerm(new Flags(Flags.Flag.SEEN), false));
if (messages.length > 0) {
Message latestUnreadMessage = messages[messages.length - 1];
latestUnreadMessage.setFlag(Flags.Flag.SEEN, true);
}
inbox.close(true);
}
public static void moveToFolder(Store store, Message message, String folderName) throws MessagingException {
Folder destinationFolder = store.getFolder(folderName);
if (!destinationFolder.exists()) {
destinationFolder.create(Folder.HOLDS_MESSAGES);
}
Message[] messagesToMove = new Message[] { message };
message.getFolder()
.copyMessages(messagesToMove, destinationFolder);
message.setFlag(Flags.Flag.DELETED, true);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/zip4j/CreateSplitZipFile.java | libraries-io/src/main/java/com/baeldung/java/io/zip4j/CreateSplitZipFile.java | package com.baeldung.java.io.zip4j;
import net.lingala.zip4j.ZipFile;
import net.lingala.zip4j.model.ZipParameters;
import net.lingala.zip4j.model.enums.EncryptionMethod;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
public class CreateSplitZipFile {
public static void main(String[] args) throws IOException {
ZipParameters zipParameters = new ZipParameters();
zipParameters.setEncryptFiles(true);
zipParameters.setEncryptionMethod(EncryptionMethod.AES);
ZipFile zipFile = new ZipFile("compressed.zip", "password".toCharArray());
int splitLength = 1024 * 1024 * 10; // 10MB
zipFile.createSplitZipFile(Arrays.asList(new File("aFile.txt")), zipParameters, true, splitLength);
zipFile.createSplitZipFileFromFolder(new File("/users/folder_to_add"), zipParameters, true, splitLength);
zipFile.close();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/zip4j/ZipSingleFile.java | libraries-io/src/main/java/com/baeldung/java/io/zip4j/ZipSingleFile.java | package com.baeldung.java.io.zip4j;
import net.lingala.zip4j.ZipFile;
import net.lingala.zip4j.model.ZipParameters;
import net.lingala.zip4j.model.enums.CompressionLevel;
import net.lingala.zip4j.model.enums.EncryptionMethod;
import java.io.File;
import java.io.IOException;
public class ZipSingleFile {
public static void main(String[] args) throws IOException {
ZipParameters zipParameters = new ZipParameters();
zipParameters.setEncryptFiles(true);
zipParameters.setCompressionLevel(CompressionLevel.HIGHER);
zipParameters.setEncryptionMethod(EncryptionMethod.AES);
ZipFile zipFile = new ZipFile("compressed.zip", "password".toCharArray());
File fileToAdd = new File("aFile.txt");
if (!fileToAdd.exists()) {
fileToAdd.createNewFile();
}
zipFile.addFile(fileToAdd, zipParameters);
zipFile.close();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/zip4j/ZipMultiFile.java | libraries-io/src/main/java/com/baeldung/java/io/zip4j/ZipMultiFile.java | package com.baeldung.java.io.zip4j;
import net.lingala.zip4j.ZipFile;
import net.lingala.zip4j.model.ZipParameters;
import net.lingala.zip4j.model.enums.EncryptionMethod;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class ZipMultiFile {
public static void main(String[] args) throws IOException {
ZipParameters zipParameters = new ZipParameters();
zipParameters.setEncryptFiles(true);
zipParameters.setEncryptionMethod(EncryptionMethod.AES);
File firstFile = new File("aFile.txt");
File secondFile = new File("bFile.txt");
if (!firstFile.exists()) {
firstFile.createNewFile();
}
if (!secondFile.exists()) {
secondFile.createNewFile();
}
List<File> filesToAdd = Arrays.asList(firstFile, secondFile);
ZipFile zipFile = new ZipFile("compressed.zip", "password".toCharArray());
zipFile.addFiles(filesToAdd, zipParameters);
zipFile.close();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/zip4j/ZipFolder.java | libraries-io/src/main/java/com/baeldung/java/io/zip4j/ZipFolder.java | package com.baeldung.java.io.zip4j;
import net.lingala.zip4j.ZipFile;
import net.lingala.zip4j.model.ZipParameters;
import net.lingala.zip4j.model.enums.EncryptionMethod;
import java.io.File;
import java.io.IOException;
public class ZipFolder {
public static void main(String[] args) throws IOException {
ZipParameters zipParameters = new ZipParameters();
zipParameters.setEncryptFiles(true);
zipParameters.setEncryptionMethod(EncryptionMethod.AES);
ZipFile zipFile = new ZipFile("compressed.zip", "password".toCharArray());
zipFile.addFolder(new File("/users/folder_to_add"), zipParameters);
zipFile.close();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/zip4j/ExtractSingleFile.java | libraries-io/src/main/java/com/baeldung/java/io/zip4j/ExtractSingleFile.java | package com.baeldung.java.io.zip4j;
import java.io.IOException;
import net.lingala.zip4j.ZipFile;
public class ExtractSingleFile {
public static void main(String[] args) throws IOException {
ZipFile zipFile = new ZipFile("compressed.zip", "password".toCharArray());
zipFile.extractFile("aFile.txt", "/destination_directory");
zipFile.close();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/zip4j/ExtractAllFile.java | libraries-io/src/main/java/com/baeldung/java/io/zip4j/ExtractAllFile.java | package com.baeldung.java.io.zip4j;
import java.io.IOException;
import net.lingala.zip4j.ZipFile;
public class ExtractAllFile {
public static void main(String[] args) throws IOException {
ZipFile zipFile = new ZipFile("compressed.zip", "password".toCharArray());
zipFile.extractAll("/destination_directory");
zipFile.close();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-io/src/main/java/com/baeldung/java/io/simplemail/SimpleMailExample.java | libraries-io/src/main/java/com/baeldung/java/io/simplemail/SimpleMailExample.java | package com.baeldung.java.io.simplemail;
import java.util.ArrayList;
import java.util.List;
import org.simplejavamail.api.email.AttachmentResource;
import org.simplejavamail.api.email.Email;
import org.simplejavamail.api.email.Recipient;
import org.simplejavamail.api.mailer.Mailer;
import org.simplejavamail.email.EmailBuilder;
import org.simplejavamail.mailer.MailerBuilder;
import org.simplejavamail.MailException;
import jakarta.activation.FileDataSource;
import jakarta.mail.Message;
public class SimpleMailExample {
public static void sendPlainTextEmail() {
Email email = EmailBuilder.startingBlank()
.from("sender@example.com")
.to("recipient@example.com")
.withSubject("Email with Plain Text!")
.withPlainText("This is a test email sent using SJM.")
.buildEmail();
sendEmail(email);
}
public static void sendPlainTextEmailToMultipleRecipient() {
Email email = EmailBuilder.startingBlank()
.from("sender@example.com")
.to("recipient1@example.com, recipient2@example.com, recipient3@example.com")
.withSubject("Email with Plain Text!")
.withPlainText("This is a test email sent using SJM to multiple recipients.")
.buildEmail();
sendEmail(email);
}
public static void sendEmailWithAttachment() {
Email email = EmailBuilder.startingBlank()
.from("sender@example.com")
.to("recipient@example.com")
.withSubject("Email with Plain Text and Attachment!")
.withPlainText("This is a test email with attachment sent using SJM.")
.withAttachment("important_document.pdf", new FileDataSource("path/to/important_document.pdf"))
.buildEmail();
sendEmail(email);
}
public static void sendEmailWithMultipleAttachment() {
List<AttachmentResource> arList = new ArrayList<>();
arList.add(new AttachmentResource("important_document.pdf", new FileDataSource("path/to/important_document.pdf")));
arList.add(new AttachmentResource("company_logo.png", new FileDataSource("path/to/company_logo.png")));
Email email = EmailBuilder.startingBlank()
.from("sender@example.com")
.to("recipient@example.com")
.withSubject("Email with Plain Text and multiple Attachments!")
.withPlainText("This is a test email with attachment sent using SJM.")
.withAttachments(arList)
.buildEmail();
sendEmail(email);
}
public static void sendHTMLTextWithEmbeddedImageEmail() {
String htmlContent = "<h1>This is an email with HTML content</h1>" + "<p>This email body contains additional information and formatting.</p>" +
"<img src=\"cid:company_logo\" alt=\"Company Logo\">";
Email email = EmailBuilder.startingBlank()
.from("sender@example.com")
.to("recipient@example.com")
.withSubject("Email with HTML and Embedded Image!")
.withHTMLText(htmlContent)
.withEmbeddedImage("company_logo", new FileDataSource("path/to/company_logo.png"))
.buildEmail();
sendEmail(email);
}
public static void replyingToEmail(Email receivedEmail) {
EmailBuilder.replyingTo(receivedEmail)
.from("sender@example.com")
.prependText("This is a Reply Email. Original email included below:")
.buildEmail();
}
public static void forwardingEmail(Email receivedEmail) {
Email email = EmailBuilder.forwarding(receivedEmail)
.from("sender@example.com")
.prependText("This is an Forward Email. See below email:")
.buildEmail();
}
public static void handleExceptionWhenSendingEmail() {
try {
sendPlainTextEmail();
System.out.println("Email sent successfully!");
} catch (MailException e) {
System.err.println("Error: " + e.getMessage());
}
}
public static void setCustomHeaderWhenSendingEmail() {
Email email = EmailBuilder.startingBlank()
.from("sender@example.com")
.to("recipient@example.com")
.withSubject("Email with Custom Header")
.withPlainText("This is an important message.")
.withHeader("X-Priority", "1")
.buildEmail();
sendEmail(email);
}
private static void sendEmailWithDeliveryReadRecipient() {
Email email = EmailBuilder.startingBlank()
.from("sender@example.com")
.to("recipient@example.com")
.withSubject("Email with Delivery/Read Receipt Configured!")
.withPlainText("This is an email sending with delivery/read receipt.")
.withDispositionNotificationTo(new Recipient("name", "address@domain.com", Message.RecipientType.TO))
.withReturnReceiptTo(new Recipient("name", "address@domain.com", Message.RecipientType.TO))
.buildEmail();
sendEmail(email);
}
private static void sendEmail(Email email) {
Mailer mailer = MailerBuilder.withSMTPServer("smtp.example.com", 25, "username", "password")
.withMaximumEmailSize(1024 * 1024 * 5) // 5 Megabytes
.buildMailer();
boolean validate = mailer.validate(email);
if (validate) {
mailer.sendMail(email);
} else {
System.out.println("Invalid email address.");
}
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-llms-2/src/test/java/com/baeldung/chatbot/mongodb/ChatBotLiveTest.java | libraries-llms-2/src/test/java/com/baeldung/chatbot/mongodb/ChatBotLiveTest.java | package com.baeldung.chatbot.mongodb;
import com.baeldung.chatbot.mongodb.configuration.ChatBotConfiguration;
import com.baeldung.chatbot.mongodb.controllers.ChatBotController;
import com.baeldung.chatbot.mongodb.repositories.ArticlesRepository;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
@AutoConfigureMockMvc
@SpringBootTest(classes = {ChatBotConfiguration.class, ArticlesRepository.class, ChatBotController.class})
class ChatBotLiveTest {
Logger log = LoggerFactory.getLogger(ChatBotLiveTest.class);
@Autowired
private MockMvc mockMvc;
@Test
void givenChatBotApi_whenCallingGetEndpointWithQuestion_thenExpectedAnswersIsPresent() throws Exception {
String chatResponse = mockMvc
.perform(get("/chat-bot")
.param("question", "Steps to implement Spring boot app and MongoDB"))
.andReturn()
.getResponse()
.getContentAsString();
log.info(chatResponse);
Assertions.assertTrue(chatResponse.contains("Step 1"));
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/controllers/ChatBotController.java | libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/controllers/ChatBotController.java | package com.baeldung.chatbot.mongodb.controllers;
import com.baeldung.chatbot.mongodb.assistants.ArticleBasedAssistant;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@RestController
public class ChatBotController {
private final ArticleBasedAssistant assistant;
@Autowired
public ChatBotController(ArticleBasedAssistant assistant) {
this.assistant = assistant;
}
@GetMapping("/chat-bot")
public String answer(@RequestParam("question") String question) {
return assistant.answer(question);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/configuration/ChatBotConfiguration.java | libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/configuration/ChatBotConfiguration.java | package com.baeldung.chatbot.mongodb.configuration;
import com.baeldung.chatbot.mongodb.assistants.ArticleBasedAssistant;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoClients;
import com.mongodb.client.model.CreateCollectionOptions;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModel;
import dev.langchain4j.rag.content.retriever.ContentRetriever;
import dev.langchain4j.rag.content.retriever.EmbeddingStoreContentRetriever;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.mongodb.IndexMapping;
import dev.langchain4j.store.embedding.mongodb.MongoDbEmbeddingStore;
import org.bson.conversions.Bson;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashSet;
import static dev.langchain4j.model.openai.OpenAiEmbeddingModelName.TEXT_EMBEDDING_3_SMALL;
@Configuration
public class ChatBotConfiguration {
@Value("${app.mongodb.url}")
private String mongodbUrl;
@Value("${app.mongodb.db-name}")
private String databaseName;
@Value("${app.openai.apiKey}")
private String apiKey;
@Bean
public MongoClient mongoClient() {
return MongoClients.create(mongodbUrl);
}
@Bean
public EmbeddingStore<TextSegment> embeddingStore(MongoClient mongoClient) {
String collectionName = "embeddings";
String indexName = "embedding";
Long maxResultRatio = 10L;
CreateCollectionOptions createCollectionOptions = new CreateCollectionOptions();
Bson filter = null;
IndexMapping indexMapping = IndexMapping.builder()
.dimension(TEXT_EMBEDDING_3_SMALL.dimension())
.metadataFieldNames(new HashSet<>())
.build();
Boolean createIndex = true;
return new MongoDbEmbeddingStore(
mongoClient,
databaseName,
collectionName,
indexName,
maxResultRatio,
createCollectionOptions,
filter,
indexMapping,
createIndex
);
}
@Bean
public EmbeddingModel embeddingModel() {
return OpenAiEmbeddingModel.builder()
.apiKey(apiKey)
.modelName(TEXT_EMBEDDING_3_SMALL)
.build();
}
@Bean
public ContentRetriever contentRetriever(EmbeddingStore<TextSegment> embeddingStore, EmbeddingModel embeddingModel) {
return EmbeddingStoreContentRetriever.builder()
.embeddingStore(embeddingStore)
.embeddingModel(embeddingModel)
.maxResults(10)
.minScore(0.8)
.build();
}
@Bean
public ChatLanguageModel chatModel() {
return OpenAiChatModel.builder()
.apiKey(apiKey)
.modelName("gpt-4o-mini")
.build();
}
@Bean
public ArticleBasedAssistant articleBasedAssistant(ChatLanguageModel chatModel, ContentRetriever contentRetriever) {
return AiServices.builder(ArticleBasedAssistant.class)
.chatLanguageModel(chatModel)
.contentRetriever(contentRetriever)
.build();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/assistants/ArticleBasedAssistant.java | libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/assistants/ArticleBasedAssistant.java | package com.baeldung.chatbot.mongodb.assistants;
public interface ArticleBasedAssistant {
String answer(String question);
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/repositories/ArticlesRepository.java | libraries-llms-2/src/main/java/com/baeldung/chatbot/mongodb/repositories/ArticlesRepository.java | package com.baeldung.chatbot.mongodb.repositories;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.DocumentSplitter;
import dev.langchain4j.data.document.Metadata;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.embedding.EmbeddingModel;
import dev.langchain4j.model.openai.OpenAiEmbeddingModelName;
import dev.langchain4j.model.openai.OpenAiTokenizer;
import dev.langchain4j.store.embedding.EmbeddingStore;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
@Component
public class ArticlesRepository {
private static final Logger log = LoggerFactory.getLogger(ArticlesRepository.class);
private final EmbeddingStore<TextSegment> embeddingStore;
private final EmbeddingModel embeddingModel;
private final ObjectMapper objectMapper = new ObjectMapper();
@Autowired
public ArticlesRepository(@Value("${app.load-articles}") Boolean shouldLoadArticles,
EmbeddingStore<TextSegment> embeddingStore, EmbeddingModel embeddingModel) throws IOException {
this.embeddingStore = embeddingStore;
this.embeddingModel = embeddingModel;
if (shouldLoadArticles) {
loadArticles();
}
}
private void loadArticles() throws IOException {
String resourcePath = "articles.json";
int maxTokensPerChunk = 8000;
int overlapTokens = 800;
List<TextSegment> documents = loadJsonDocuments(resourcePath, maxTokensPerChunk, overlapTokens);
log.info("Documents to store: " + documents.size());
for (TextSegment document : documents) {
Embedding embedding = embeddingModel.embed(document.text()).content();
embeddingStore.add(embedding, document);
}
log.info("Documents are uploaded");
}
private List<TextSegment> loadJsonDocuments(String resourcePath, int maxTokensPerChunk, int overlapTokens) throws IOException {
InputStream inputStream = ArticlesRepository.class.getClassLoader().getResourceAsStream(resourcePath);
if (inputStream == null) {
throw new FileNotFoundException("Resource not found: " + resourcePath);
}
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
int batchSize = 500;
List<Document> batch = new ArrayList<>();
List<TextSegment> textSegments = new ArrayList<>();
String line;
while ((line = reader.readLine()) != null) {
JsonNode jsonNode = objectMapper.readTree(line);
String title = jsonNode.path("title").asText(null);
String body = jsonNode.path("body").asText(null);
JsonNode metadataNode = jsonNode.path("metadata");
if (body != null) {
addDocumentToBatch(title, body, metadataNode, batch);
if (batch.size() >= batchSize) {
textSegments.addAll(splitIntoChunks(batch, maxTokensPerChunk, overlapTokens));
batch.clear();
}
}
}
if (!batch.isEmpty()) {
textSegments.addAll(splitIntoChunks(batch, maxTokensPerChunk, overlapTokens));
}
return textSegments;
}
private void addDocumentToBatch(String title, String body, JsonNode metadataNode, List<Document> batch) {
String text = (title != null ? title + "\n\n" + body : body);
Metadata metadata = new Metadata();
if (metadataNode != null && metadataNode.isObject()) {
Iterator<String> fieldNames = metadataNode.fieldNames();
while (fieldNames.hasNext()) {
String fieldName = fieldNames.next();
metadata.put(fieldName, metadataNode.path(fieldName).asText());
}
}
Document document = Document.from(text, metadata);
batch.add(document);
}
private List<TextSegment> splitIntoChunks(List<Document> documents, int maxTokensPerChunk, int overlapTokens) {
OpenAiTokenizer tokenizer = new OpenAiTokenizer(OpenAiEmbeddingModelName.TEXT_EMBEDDING_3_SMALL);
DocumentSplitter splitter = DocumentSplitters.recursive(
maxTokensPerChunk,
overlapTokens,
tokenizer
);
List<TextSegment> allSegments = new ArrayList<>();
for (Document document : documents) {
List<TextSegment> segments = splitter.split(document);
allSegments.addAll(segments);
}
return allSegments;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/google-cloud/src/test/java/com/baeldung/google/cloud/translator/TranslatorLiveTest.java | google-cloud/src/test/java/com/baeldung/google/cloud/translator/TranslatorLiveTest.java | package com.baeldung.google.cloud.translator;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.List;
import org.junit.jupiter.api.Test;
public class TranslatorLiveTest {
@Test
void whenTranslateTextIsCalledWithEnglishTextAndFrenchTargetLanguage_thenReturnTranslatedText() {
String originalText = "Hello, world!";
String targetLanguage = "es";
String expectedTranslatedText = "¡Hola Mundo!";
String translatedText = Translator.translateText(originalText, targetLanguage);
assertEquals(expectedTranslatedText, translatedText);
}
@Test
void whenTranslateTextIsCalledWithEnglishHTMLAndFrenchTargetLanguage_thenReturnTranslatedHTML() {
String originalHtml = "<p>Hello, world!</p>";
String targetLanguage = "es";
String expectedTranslatedHtml = "<p>¡Hola Mundo!</p>";
String translatedHtml = Translator.translateText(originalHtml, targetLanguage);
assertEquals(expectedTranslatedHtml, translatedHtml);
}
@Test
void whenDetectLanguageIsCalledWithSpanishText_thenReturnSpanishLanguageCode() {
String text = "Hola, mundo!";
String expectedLanguageCode = "es";
String detectedLanguage = Translator.detectLanguage(text);
assertEquals(expectedLanguageCode, detectedLanguage);
}
@Test
void whenTranslateBatchIsCalledWithMultipleTexts_thenReturnTranslatedTexts() {
List<String> originalTexts = List.of("Apple", "Banana", "Orange");
List<String> expectedTranslatedTexts = List.of("Pomme", "Banane", "Orange");
List<String> translatedTexts = Translator.translateBatch(originalTexts, "fr");
assertEquals(expectedTranslatedTexts, translatedTexts);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/google-cloud/src/main/java/com/baeldung/google/cloud/storage/GoogleCloudStorage.java | google-cloud/src/main/java/com/baeldung/google/cloud/storage/GoogleCloudStorage.java | package com.baeldung.google.cloud.storage;
import com.google.api.gax.paging.Page;
import com.google.auth.Credentials;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.cloud.storage.*;
import lombok.extern.slf4j.Slf4j;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.WritableByteChannel;
import static java.nio.charset.StandardCharsets.UTF_8;
/**
* Simple class for creating, reading and modifying text blobs on Google Cloud
*/
@Slf4j
public class GoogleCloudStorage {
private Storage storage;
private Bucket bucket;
public static void main(String[] args) throws Exception {
// Use this variation to read the Google authorization JSON from the resources directory with a path
// and a project name.
GoogleCloudStorage googleCloudStorage =
new GoogleCloudStorage("google-cloud/src/main/resources/google_auth.json", "baeldung-cloud-tutorial");
// Bucket require globally unique names, so you'll probably need to change this
Bucket bucket = googleCloudStorage.getBucket("baeldung-1-bucket");
// Save a simple string
BlobId blobId = googleCloudStorage.saveString("my-first-blob", "Hi there!", bucket);
// Get it by blob id this time
String value = googleCloudStorage.getString(blobId);
log.info("Read data: {}", value);
googleCloudStorage.updateString(blobId, "Bye now!");
// Get the string by blob name
value = googleCloudStorage.getString("my-first-blob");
log.info("Read modified data: {}", value);
}
// Use path and project name
private GoogleCloudStorage(String pathToConfig, String projectId) throws IOException {
Credentials credentials = GoogleCredentials.fromStream(new FileInputStream(pathToConfig));
storage = StorageOptions.newBuilder().setCredentials(credentials).setProjectId(projectId).build().getService();
}
// Check for bucket existence and create if needed.
private Bucket getBucket(String bucketName) {
bucket = storage.get(bucketName);
if (bucket == null) {
System.out.println("Creating new bucket.");
bucket = storage.create(BucketInfo.of(bucketName));
}
return bucket;
}
// Save a string to a blob
private BlobId saveString(String blobName, String value, Bucket bucket) {
byte[] bytes = value.getBytes(UTF_8);
Blob blob = bucket.create(blobName, bytes);
return blob.getBlobId();
}
// get a blob by id
private String getString(BlobId blobId) {
Blob blob = storage.get(blobId);
return new String(blob.getContent());
}
// get a blob by name
private String getString(String name) {
Page<Blob> blobs = bucket.list();
for (Blob blob: blobs.getValues()) {
if (name.equals(blob.getName())) {
return new String(blob.getContent());
}
}
return "Blob not found";
}
// Update a blob
private void updateString(BlobId blobId, String newString) throws IOException {
Blob blob = storage.get(blobId);
if (blob != null) {
WritableByteChannel channel = blob.writer();
channel.write(ByteBuffer.wrap(newString.getBytes(UTF_8)));
channel.close();
}
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/google-cloud/src/main/java/com/baeldung/google/cloud/translator/Translator.java | google-cloud/src/main/java/com/baeldung/google/cloud/translator/Translator.java | package com.baeldung.google.cloud.translator;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.cloud.translate.Language;
import com.google.cloud.translate.Translate;
import com.google.cloud.translate.TranslateOptions;
import com.google.cloud.translate.Translation;
import com.google.cloud.translate.v3.GlossaryName;
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslateTextGlossaryConfig;
import com.google.cloud.translate.v3.TranslateTextRequest;
import com.google.cloud.translate.v3.TranslateTextResponse;
import com.google.cloud.translate.v3.TranslationServiceClient;
public class Translator {
private static final Logger logger = LoggerFactory.getLogger(Translator.class);
private static Translate translate;
static {
initializeTranslateClient();
}
public static void initializeTranslateClient() {
if (translate == null) {
try {
GoogleCredentials credentials = GoogleCredentials.fromStream(
new FileInputStream("src/main/resources/translator_permission.json")
);
translate = TranslateOptions.newBuilder()
.setCredentials(credentials)
.build()
.getService();
logger.info("Google Translate client initialized.");
} catch (Exception e) {
logger.error("Failed to initialize Google Translate client.", e);
}
}
}
public static void listSupportedLanguages() {
try {
List<Language> languages = translate.listSupportedLanguages();
for (Language language : languages) {
logger.info(String.format("Name: %s, Code: %s", language.getName(), language.getCode()));
}
} catch (Exception e) {
// handle exception
}
}
public static void listSupportedLanguagesWithSpecificLanguage() {
try {
List<Language> languages = translate.listSupportedLanguages(Translate.LanguageListOption.targetLanguage("es"));
for (Language language : languages) {
logger.info(String.format("Name: %s, Code: %s", language.getName(), language.getCode()));
}
} catch (Exception e) {
// handle exception
}
}
public static String translateText(String text, String targetLanguage) {
String s = "";
try {
Translation translation = translate.translate(text, Translate.TranslateOption.targetLanguage(targetLanguage));
s = translation.getTranslatedText();
} catch (Exception e) {
e.printStackTrace();
// handle exception
}
return s;
}
public static String detectLanguage(String text) {
return translate.detect(text)
.getLanguage();
}
public static List<String> translateBatch(List<String> texts, String targetLanguage) {
List<String> translationList = null;
try {
List<Translation> translations = translate.translate(texts, Translate.TranslateOption.targetLanguage(targetLanguage));
translationList = translations.stream()
.map(Translation::getTranslatedText)
.collect(Collectors.toList());
} catch (Exception e) {
// handle exception
}
return translationList;
}
public static String translateWithGlossary(String projectId, String location, String text, String targetLanguage, String glossaryId) {
String translatedText = "";
try (TranslationServiceClient client = TranslationServiceClient.create()) {
LocationName parent = LocationName.of(projectId, location);
GlossaryName glossaryName = GlossaryName.of(projectId, location, glossaryId);
TranslateTextRequest request = TranslateTextRequest.newBuilder()
.setParent(parent.toString())
.setTargetLanguageCode(targetLanguage)
.addContents(text)
.setGlossaryConfig(TranslateTextGlossaryConfig.newBuilder()
.setGlossary(glossaryName.toString()).build()) // Attach glossary
.build();
TranslateTextResponse response = client.translateText(request);
translatedText = response.getTranslations(0).getTranslatedText();
} catch (IOException e) {
// handle exception
}
return translatedText;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/solarwinds-loggly/src/test/java/com/baeldung/loggly/LogglyLogbackLiveTest.java | logging-modules/solarwinds-loggly/src/test/java/com/baeldung/loggly/LogglyLogbackLiveTest.java | package com.baeldung.loggly;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LogglyLogbackLiveTest {
Logger logger = LoggerFactory.getLogger(LogglyLogbackLiveTest.class);
@Test
void givenLoggly_whenLogEvent_thenPushEventToLoggly() {
logger.info("This is a logback test info message");
logger.debug("This is a logback test debug message");
logger.error("This is a logback test error message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/solarwinds-loggly/src/test/java/com/baeldung/loggly/LogglyLog4jLiveTest.java | logging-modules/solarwinds-loggly/src/test/java/com/baeldung/loggly/LogglyLog4jLiveTest.java | package com.baeldung.loggly;
import org.apache.log4j.Logger;
import org.junit.jupiter.api.Test;
public class LogglyLog4jLiveTest {
private static final Logger logger = Logger.getLogger(LogglyLog4jLiveTest.class);
@Test
void givenLoggly_whenLogEvent_thenPushEventToLoggly() {
logger.info("This is a log4j 1 test info message");
logger.debug("This is a log4j 1 test debug message");
logger.error("This is a log4j 1 test error message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/solarwinds-loggly/src/test/java/com/baeldung/loggly/LogglyLog4j2LiveTest.java | logging-modules/solarwinds-loggly/src/test/java/com/baeldung/loggly/LogglyLog4j2LiveTest.java | package com.baeldung.loggly;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Test;
public class LogglyLog4j2LiveTest {
private static final Logger logger = LogManager.getLogger(LogglyLog4j2LiveTest.class);
@Test
void givenLoggly_whenLogEvent_thenPushEventToLoggly() {
logger.info("This is a log4j2 test info message");
logger.debug("This is a log4j2 test debug message");
logger.error("This is a log4j2 test error message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/splunk-with-log4j2/src/test/java/com/splunk/log4j/controller/StudentControllerUnitTest.java | logging-modules/splunk-with-log4j2/src/test/java/com/splunk/log4j/controller/StudentControllerUnitTest.java | package com.splunk.log4j.controller;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.splunk.log4j.dto.Student;
import com.splunk.log4j.service.StudentService;
@WebMvcTest(StudentController.class)
class StudentControllerUnitTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private StudentService studentService;
@Autowired
private ObjectMapper objectMapper;
@Test
void whenAddStudentCalled_thenReturnSuccessAndAddedStudent() throws Exception {
Student student = new Student();
student.setName("Ram");
student.setRollNumber(3);
when(studentService.addStudent(student)).thenReturn(student);
mockMvc.perform(post("/students").contentType(MediaType.APPLICATION_JSON)
.content(objectMapper.writeValueAsString(student)))
.andExpect(status().isOk())
.andExpect(content().json(objectMapper.writeValueAsString(student)))
.andReturn();
}
@Test
void whenGetStudentCalled_thenReturnStudentByIndex() throws Exception {
Student student = new Student();
student.setName("Ram");
student.setRollNumber(4);
when(studentService.getStudent(0)).thenReturn(student);
mockMvc.perform(get("/students/0"))
.andExpect(status().isOk())
.andExpect(content().json(objectMapper.writeValueAsString(student)));
}
@Test
void whenGetStudentsCalled_thenReturnListOfStudent() throws Exception {
Student student = new Student();
student.setName("Ram");
student.setRollNumber(4);
Student student2 = new Student();
student.setName("Sham");
student.setRollNumber(3);
when(studentService.getStudents()).thenReturn(List.of(student, student2));
mockMvc.perform(get("/students"))
.andExpect(status().isOk())
.andExpect(content().json(objectMapper.writeValueAsString(List.of(student, student2))));
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/splunk-with-log4j2/src/test/java/com/splunk/log4j/service/StudentServiceUnitTest.java | logging-modules/splunk-with-log4j2/src/test/java/com/splunk/log4j/service/StudentServiceUnitTest.java | package com.splunk.log4j.service;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import com.splunk.log4j.dto.Student;
@SpringBootTest
class StudentServiceUnitTest {
@Autowired
private StudentService studentService;
@Test
void whenAddStudentCalled_thenReturnAddedStudent() {
Student student = new Student();
student.setName("Ram");
student.setRollNumber(4);
Student student2 = studentService.addStudent(student);
Assertions.assertEquals(student2.getName(), student.getName());
Assertions.assertEquals(student2.getRollNumber(), student.getRollNumber());
}
@Test
void whenGetStudentsCalled_thenReturnListOfStudent() {
Student student = new Student();
student.setName("Ram");
student.setRollNumber(4);
Student student2 = new Student();
student.setName("Sham");
student.setRollNumber(5);
studentService.addStudent(student);
studentService.addStudent(student2);
List<Student> studentList = studentService.getStudents();
Student student3 = studentList.stream()
.filter(s -> s.getRollNumber() == 5)
.findFirst()
.orElseThrow(() -> new RuntimeException("Student not found"));
Assertions.assertNotNull(student3);
Assertions.assertEquals(5, student3.getRollNumber());
}
@Test
void whenGetStudentCalled_thenStudentByIndex() {
Student student = new Student();
student.setName("Ram");
student.setRollNumber(4);
studentService.addStudent(student);
Student student2 = studentService.getStudent(4);
Assertions.assertEquals(student2.getRollNumber(), student.getRollNumber());
Assertions.assertEquals(student2.getName(), student.getName());
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/Log4jApplication.java | logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/Log4jApplication.java | package com.splunk.log4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Log4jApplication {
public static void main(String[] args) {
SpringApplication.run(Log4jApplication.class, args);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/controller/StudentController.java | logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/controller/StudentController.java | package com.splunk.log4j.controller;
import java.util.List;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.splunk.log4j.dto.Student;
import com.splunk.log4j.service.StudentService;
@RestController
@RequestMapping("students")
public class StudentController {
private final StudentService studentService;
public StudentController(StudentService studentService) {
this.studentService = studentService;
}
@PostMapping
public Student addStudent(@RequestBody Student student) {
return studentService.addStudent(student);
}
@GetMapping
public List<Student> getStudents() {
return studentService.getStudents();
}
@GetMapping("{rollNumber}")
public Student getStudent(@PathVariable("rollNumber") int rollNumber) {
return studentService.getStudent(rollNumber);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/dto/Student.java | logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/dto/Student.java | package com.splunk.log4j.dto;
import java.util.Objects;
public class Student {
private String name;
private int rollNumber;
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getRollNumber() {
return rollNumber;
}
public void setRollNumber(int rollNumber) {
this.rollNumber = rollNumber;
}
@Override
public String toString() {
return "Student{" + "name='" + name + '\'' + ", rollNumber=" + rollNumber + '}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Student student = (Student) o;
if (rollNumber != student.rollNumber) {
return false;
}
return Objects.equals(name, student.name);
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + rollNumber;
return result;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/service/StudentService.java | logging-modules/splunk-with-log4j2/src/main/java/com/splunk/log4j/service/StudentService.java | package com.splunk.log4j.service;
import java.util.ArrayList;
import java.util.List;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.stereotype.Service;
import com.splunk.log4j.dto.Student;
@Service
public class StudentService {
private static final Logger logger = LogManager.getLogger(StudentService.class);
private final List<Student> students = new ArrayList<>();
public Student addStudent(Student student) {
logger.info("addStudent: adding Student");
logger.info("addStudent: Request: {}", student);
students.add(student);
logger.info("addStudent: added Student");
logger.info("addStudent: Response: {}", student);
return student;
}
public List<Student> getStudents() {
logger.info("getStudents: getting Students");
List<Student> studentsList = students;
logger.info("getStudents: got Students");
logger.info("getStudents: Response: {}", studentsList);
return studentsList;
}
public Student getStudent(int rollNumber) {
logger.info("getStudent: getting Student");
logger.info("getStudent: Request: {}", rollNumber);
Student student = students.stream()
.filter(stu -> stu.getRollNumber() == rollNumber)
.findAny()
.orElseThrow(() -> new RuntimeException("Student not found"));
logger.info("getStudent: got Student");
logger.info("getStudent: Response: {}", student);
return student;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/tinylog2/src/test/java/com/baeldung/tinylog/TinylogIntegrationTest.java | logging-modules/tinylog2/src/test/java/com/baeldung/tinylog/TinylogIntegrationTest.java | package com.baeldung.tinylog;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.tinylog.Logger;
import static org.assertj.core.api.Assertions.assertThat;
public class TinylogIntegrationTest {
private ByteArrayOutputStream consoleOutput = new ByteArrayOutputStream();
@BeforeEach
public void init() throws UnsupportedEncodingException {
System.setOut(new PrintStream(consoleOutput, false, "UTF-8"));
}
@Test
public void whenLoggingStaticText_thenOutputIt() throws UnsupportedEncodingException {
Logger.info("Hello World!");
String outputLog = consoleOutput.toString("UTF-8");
assertThat(outputLog).isEqualToIgnoringNewLines("Hello World!");
}
@Test
public void whenLoggingParamizedText_thenOutputItResolved() throws UnsupportedEncodingException {
Logger.info("Hello {}!", "Alice");
String outputLog = consoleOutput.toString("UTF-8");
assertThat(outputLog).isEqualToIgnoringNewLines("Hello Alice!");
}
@Test
public void whenLoggingNumberWithFormatPattern_thenOutputItFormatted() throws UnsupportedEncodingException {
Logger.info("π = {0.00}", Math.PI);
String outputLog = consoleOutput.toString("UTF-8");
assertThat(outputLog).isEqualToIgnoringNewLines("π = 3.14");
}
@Test
public void whenLoggingExceptionWithMessage_thenOutputMessageAndException() throws UnsupportedEncodingException {
int a = 42;
int b = 0;
try {
int i = a / b;
} catch (Exception ex) {
Logger.error(ex, "Cannot divide {} by {}", a, b);
}
String outputLog = consoleOutput.toString("UTF-8");
assertThat(outputLog).startsWith("Cannot divide 42 by 0: java.lang.ArithmeticException");
}
@Test
public void whenLoggingExceptionWithoutMessage_thenOutputExceptionOnly() throws UnsupportedEncodingException {
try {
int i = 42 / 0;
} catch (Exception ex) {
Logger.error(ex);
}
String outputLog = consoleOutput.toString("UTF-8");
assertThat(outputLog).startsWith("java.lang.ArithmeticException");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/tinylog2/src/main/java/com/baeldung/tinylog/TinylogExamples.java | logging-modules/tinylog2/src/main/java/com/baeldung/tinylog/TinylogExamples.java | package com.baeldung.tinylog;
import org.tinylog.Logger;
public class TinylogExamples {
public static void main(String[] args) {
/* Static text */
Logger.info("Hello World!");
/* Placeholders */
Logger.info("Hello {}!", "Alice");
Logger.info("π = {0.00}", Math.PI);
/* Lazy Logging */
Logger.debug("Expensive computation: {}", () -> compute()); // Visible in log files but not on the console
/* Exceptions */
int a = 42;
int b = 0;
try {
int i = a / b;
} catch (Exception ex) {
Logger.error(ex, "Cannot divide {} by {}", a, b);
}
try {
int i = a / b;
} catch (Exception ex) {
Logger.error(ex);
}
}
private static int compute() {
return 42; // In real applications, we would perform an expensive computation here
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/Log4j2BaseIntegrationTest.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/Log4j2BaseIntegrationTest.java | package com.baeldung.logging.log4j2;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.spi.LoggerContextFactory;
import org.junit.AfterClass;
import java.lang.reflect.Field;
public class Log4j2BaseIntegrationTest {
@AfterClass
public static void tearDown() throws Exception {
Field factories = ConfigurationFactory.class.getDeclaredField("factories");
factories.setAccessible(true);
factories.set(null, null);
ConfigurationFactory.resetConfigurationFactory();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfiguration/CustomConfigurationFactory.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfiguration/CustomConfigurationFactory.java | /**
This class demonstrates how to build the components of
the configuration factory, as described in Section 3 of
"Programmatic Configuration with Log4j 2"
**/
package com.baeldung.logging.log4j2.simpleconfiguration;
import java.io.IOException;
import java.net.URI;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.Order;
import org.apache.logging.log4j.core.config.builder.api.AppenderComponentBuilder;
import org.apache.logging.log4j.core.config.builder.api.ComponentBuilder;
import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilder;
import org.apache.logging.log4j.core.config.builder.api.FilterComponentBuilder;
import org.apache.logging.log4j.core.config.builder.api.LayoutComponentBuilder;
import org.apache.logging.log4j.core.config.builder.api.LoggerComponentBuilder;
import org.apache.logging.log4j.core.config.builder.api.RootLoggerComponentBuilder;
import org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration;
import org.apache.logging.log4j.core.config.plugins.Plugin;
@Plugin(name = "simple", category = ConfigurationFactory.CATEGORY)
@Order(50)
public class CustomConfigurationFactory extends ConfigurationFactory {
static Configuration createConfiguration(final String name, ConfigurationBuilder<BuiltConfiguration> builder) {
AppenderComponentBuilder console = builder.newAppender("Stdout", "Console");
LayoutComponentBuilder layout = builder.newLayout("PatternLayout")
.addAttribute("pattern", "%d [%t] %-5level: %msg%n%throwable");
console.add(layout);
FilterComponentBuilder filter = builder.newFilter("MarkerFilter", Filter.Result.ACCEPT, Filter.Result.DENY);
filter.addAttribute("marker", "FLOW");
console.add(filter);
builder.add(console);
ComponentBuilder triggeringPolicies = builder.newComponent("Policies")
.addComponent(builder.newComponent("CronTriggeringPolicy")
.addAttribute("schedule", "0 0 0 * * ?"))
.addComponent(builder.newComponent("SizeBasedTriggeringPolicy")
.addAttribute("size", "100M"));
AppenderComponentBuilder rollingFile = builder.newAppender("rolling", "RollingFile");
rollingFile.addAttribute("fileName", "target/rolling.log");
rollingFile.addAttribute("filePattern", "target/archive/rolling-%d{MM-dd-yy}.log.gz");
rollingFile.add(layout);
rollingFile.addComponent(triggeringPolicies);
builder.add(rollingFile);
AppenderComponentBuilder file = builder.newAppender("FileSystem", "File");
file.addAttribute("fileName", "target/logging.log");
file.add(layout);
builder.add(file);
LoggerComponentBuilder logger = builder.newLogger("com", Level.DEBUG);
logger.add(builder.newAppenderRef("Stdout"));
logger.add(builder.newAppenderRef("rolling"));
logger.add(builder.newAppenderRef("FileSystem"));
logger.addAttribute("additivity", false);
builder.add(logger);
RootLoggerComponentBuilder rootLogger = builder.newRootLogger(Level.ERROR);
rootLogger.add(builder.newAppenderRef("Stdout"));
rootLogger.add(builder.newAppenderRef("rolling"));
// rootLogger.add(builder.newAppenderRef("syslogAppender"));
rootLogger.add(builder.newAppenderRef("FileSystem"));
rootLogger.addAttribute("additivity", false);
builder.add(rootLogger);
try {
builder.writeXmlConfiguration(System.out);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return builder.build();
}
@Override
public Configuration getConfiguration(LoggerContext loggerContext, ConfigurationSource source) {
return getConfiguration(loggerContext, source.toString(), null);
}
public Configuration getConfiguration(final LoggerContext loggerContext, final String name, final URI configLocation) {
ConfigurationBuilder<BuiltConfiguration> builder = newConfigurationBuilder();
return createConfiguration(name, builder);
}
@Override
protected String[] getSupportedTypes() {
return new String[] { "*" };
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfiguration/SimpleConfigurationIntegrationTest.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfiguration/SimpleConfigurationIntegrationTest.java | /**
This class invokes the configuration factory through the run time property,
as defined in section 4.2 of the "Programmatic Configuration with Log4j 2"
**/
package com.baeldung.logging.log4j2.simpleconfiguration;
import com.baeldung.logging.log4j2.Log4j2BaseIntegrationTest;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.MarkerManager;
import org.apache.logging.log4j.core.config.plugins.util.PluginManager;
import org.junit.BeforeClass;
import org.junit.Test;
public class SimpleConfigurationIntegrationTest extends Log4j2BaseIntegrationTest {
@BeforeClass
public static void setUp() {
PluginManager.addPackage("com.baeldung.logging.log4j2.simpleconfiguration");
}
@Test
public void givenSimpleConfigurationPlugin_whenUsingFlowMarkers_thenLogsCorrectly() throws Exception {
Logger logger = LogManager.getLogger(this.getClass());
Marker markerContent = MarkerManager.getMarker("FLOW");
logger.debug(markerContent, "Debug log message");
logger.info(markerContent, "Info log message");
logger.error(markerContent, "Error log message");
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/tests/LambdaExpressionsIntegrationTest.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/tests/LambdaExpressionsIntegrationTest.java | package com.baeldung.logging.log4j2.tests;
import java.util.Random;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.Test;
public class LambdaExpressionsIntegrationTest {
private static final Logger logger = LogManager.getRootLogger();
@Test
public void whenCheckLogMessage_thenOk() {
if (logger.isTraceEnabled()) {
logger.trace("Numer is {}", getRandomNumber());
}
}
@Test
public void whenUseLambdaExpression_thenOk() {
logger.trace("Number is {}", () -> getRandomNumber());
logger.trace("Name is {} and age is {}", () -> getName(), () -> getRandomNumber());
}
private int getRandomNumber() {
return (new Random()).nextInt(10);
}
private String getName() {
return "John";
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfigurator/LogPrinter.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfigurator/LogPrinter.java | package com.baeldung.logging.log4j2.simpleconfigurator;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class LogPrinter {
private Logger logger = LogManager.getLogger();
public void printlog() {
logger.debug("Debug log message");
logger.info("Info log message");
logger.error("Error log message");
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfigurator/SimpleConfiguratorIntegrationTest.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/simpleconfigurator/SimpleConfiguratorIntegrationTest.java | /**
* This class demonstrates how to use ConfigurationBuilderFactory directly,
* as described in Section 3 of "Programmatic Configuration with Log4j 2"
**/
package com.baeldung.logging.log4j2.simpleconfigurator;
import com.baeldung.logging.log4j2.Log4j2BaseIntegrationTest;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.appender.ConsoleAppender;
import org.apache.logging.log4j.core.config.Configurator;
import org.apache.logging.log4j.core.config.builder.api.AppenderComponentBuilder;
import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilder;
import org.apache.logging.log4j.core.config.builder.api.ConfigurationBuilderFactory;
import org.apache.logging.log4j.core.config.builder.impl.BuiltConfiguration;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class SimpleConfiguratorIntegrationTest extends Log4j2BaseIntegrationTest {
@Test
public void givenDefaultLog4j2Environment_whenProgrammaticallyConfigured_thenLogsCorrectly() {
ConfigurationBuilder<BuiltConfiguration> builder = ConfigurationBuilderFactory.newConfigurationBuilder();
AppenderComponentBuilder console = builder.newAppender("Stdout", "CONSOLE")
.addAttribute("target", ConsoleAppender.Target.SYSTEM_OUT);
console.add(builder.newLayout("PatternLayout")
.addAttribute("pattern", "%d [%t] %-5level: %msg%n%throwable"));
builder.add(console);
builder.add(builder.newLogger("com", Level.DEBUG)
.add(builder.newAppenderRef("Stdout"))
.addAttribute("additivity", false));
builder.add(builder.newRootLogger(Level.ERROR)
.add(builder.newAppenderRef("Stdout")));
Configurator.initialize(builder.build());
LogPrinter logPrinter = new LogPrinter();
logPrinter.printlog();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/appender/MapAppenderUnitTest.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/appender/MapAppenderUnitTest.java | package com.baeldung.logging.log4j2.appender;
import static org.junit.Assert.assertEquals;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class MapAppenderUnitTest {
private Logger logger;
@Before
public void setup() {
logger = LogManager.getLogger(MapAppenderUnitTest.class);
}
@Test
public void whenLoggerEmitsLoggingEvent_thenAppenderReceivesEvent() throws Exception {
LoggerContext context = LoggerContext.getContext(false);
Configuration config = context.getConfiguration();
MapAppender appender = config.getAppender("MapAppender");
int eventSizeBeforeLog = appender.getEventMap()
.size();
logger.error("Error log message from {}", this.getClass()
.getSimpleName());
assertEquals(appender.getEventMap()
.size(), ++eventSizeBeforeLog);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/xmlconfiguration/CustomXMLConfigurationFactory.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/xmlconfiguration/CustomXMLConfigurationFactory.java | package com.baeldung.logging.log4j2.xmlconfiguration;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.Order;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.xml.XmlConfigurationFactory;
@Plugin(name = "xml", category = ConfigurationFactory.CATEGORY)
@Order(50)
public class CustomXMLConfigurationFactory extends XmlConfigurationFactory {
@Override
public Configuration getConfiguration(LoggerContext loggerContext, ConfigurationSource source) {
return new MyXMLConfiguration(loggerContext, source);
}
@Override
public String[] getSupportedTypes() {
return new String[] { ".xml", "*" };
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/xmlconfiguration/XMLConfigLogIntegrationTest.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/xmlconfiguration/XMLConfigLogIntegrationTest.java |
/**
This class loads the logging configuration from the xml defined in
src/main/resources and uses the same configuration generated through
programmatic configuration as defined in simple-configuration example.
**/
package com.baeldung.logging.log4j2.xmlconfiguration;
import com.baeldung.logging.log4j2.Log4j2BaseIntegrationTest;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.MarkerManager;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.plugins.util.PluginManager;
import org.junit.BeforeClass;
import org.junit.Test;
public class XMLConfigLogIntegrationTest extends Log4j2BaseIntegrationTest {
@BeforeClass
public static void setUp() {
PluginManager.addPackage("com.baeldung.logging.log4j2.xmlconfiguration");
}
@Test
public void givenXMLConfigurationPlugin_whenUsingFlowMarkers_ThenLogsCorrectly() throws Exception {
Logger logger = LogManager.getLogger(this.getClass());
Marker markerContent = MarkerManager.getMarker("FLOW");
logger.debug(markerContent, "Debug log message");
logger.info(markerContent, "Info log message");
logger.error(markerContent, "Error log message");
}
@Test
public void givenXMLConfigurationPlugin_whenSimpleLog_ThenLogsCorrectly() throws Exception {
Logger logger = LogManager.getLogger(this.getClass());
LoggerContext ctx = (LoggerContext) LogManager.getContext();
logger.debug("Debug log message");
logger.info("Info log message");
logger.error("Error log message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/xmlconfiguration/MyXMLConfiguration.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/xmlconfiguration/MyXMLConfiguration.java | /**
This class demonstrates on overriding the configuration loaded through xml
as defined in section 4.4 of "Programmatic Configuration with Log4j 2"
**/
package com.baeldung.logging.log4j2.xmlconfiguration;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.appender.FileAppender;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.apache.logging.log4j.core.config.xml.XmlConfiguration;
import org.apache.logging.log4j.core.layout.PatternLayout;
public class MyXMLConfiguration extends XmlConfiguration {
public MyXMLConfiguration(LoggerContext loggerContext, ConfigurationSource source) {
super(loggerContext, source);
}
@Override
protected void doConfigure() {
super.doConfigure();
final LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
Configuration config = ctx.getConfiguration();
LoggerConfig loggerConfig = config.getLoggerConfig("com");
final Layout layout = PatternLayout.createLayout("[%-5level] %d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %c{1} - %msg%n", null, config, null, null, false, false, null, null);
Appender appender = FileAppender.createAppender("target/test.log", "false", "false", "File", "true", "false", "false", "4000", layout, null, "false", null, config);
loggerConfig.addAppender(appender, Level.DEBUG, null);
addAppender(appender);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/setconfigurationfactory/SetConfigurationFactoryIntegrationTest.java | logging-modules/log4j2/src/test/java/com/baeldung/logging/log4j2/setconfigurationfactory/SetConfigurationFactoryIntegrationTest.java | /**
This class invokes the configuration factory with static initialization,
as defined in section 4.1 of the "Programmatic Configuration with Log4j 2"
**/
package com.baeldung.logging.log4j2.setconfigurationfactory;
import com.baeldung.logging.log4j2.Log4j2BaseIntegrationTest;
import com.baeldung.logging.log4j2.simpleconfiguration.CustomConfigurationFactory;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.MarkerManager;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@RunWith(JUnit4.class)
public class SetConfigurationFactoryIntegrationTest extends Log4j2BaseIntegrationTest {
@BeforeClass
public static void setUp() {
CustomConfigurationFactory customConfigurationFactory = new CustomConfigurationFactory();
ConfigurationFactory.setConfigurationFactory(customConfigurationFactory);
}
@Test
public void givenDirectConfiguration_whenUsingFlowMarkers_ThenLogsCorrectly() {
Logger logger = LogManager.getLogger(this.getClass());
Marker markerContent = MarkerManager.getMarker("FLOW");
logger.debug(markerContent, "Debug log message");
logger.info(markerContent, "Info log message");
logger.error(markerContent, "Error log message");
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/Log4j2Example.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/Log4j2Example.java | package com.baeldung.logging.log4j2;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class Log4j2Example {
private static final Logger logger = LogManager.getLogger(Log4j2Example.class);
public static void main(String[] args) {
logger.debug("Debug log message");
logger.info("Info log message");
logger.error("Error log message");
logger.warn("Warn log message");
logger.fatal("Fatal log message");
logger.trace("Trace log message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/Log4j2ComparisonSysout.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/Log4j2ComparisonSysout.java | package com.baeldung.logging.log4j2;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;
public class Log4j2ComparisonSysout {
public static void main(String[] args) throws FileNotFoundException {
PrintStream outStream = new PrintStream(new File("outFile.txt"));
System.setOut(outStream);
System.out.println("This is a baeldung article");
PrintStream errStream = new PrintStream(new File("errFile.txt"));
System.setErr(errStream);
System.err.println("This is a baeldung article error");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/ListAppender.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/ListAppender.java | /**
*
*/
package com.baeldung.logging.log4j2.plugins;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.Core;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.appender.AbstractAppender;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
import org.apache.logging.log4j.core.config.plugins.PluginElement;
import org.apache.logging.log4j.core.config.plugins.PluginFactory;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static java.util.Collections.synchronizedList;
@Plugin(name = "ListAppender", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE)
public class ListAppender extends AbstractAppender {
private List<LogEvent> logList;
protected ListAppender(String name, Filter filter) {
super(name, filter, null);
logList = synchronizedList(new ArrayList<>());
}
@PluginFactory
public static ListAppender createAppender(@PluginAttribute("name") String name, @PluginElement("Filter") final Filter filter) {
return new ListAppender(name, filter);
}
@Override
public void append(LogEvent event) {
if (event.getLevel()
.isLessSpecificThan(Level.WARN)) {
error("Unable to log less than WARN level.");
return;
}
logList.add(event);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/KafkaLookup.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/KafkaLookup.java | package com.baeldung.logging.log4j2.plugins;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.lookup.StrLookup;
@Plugin(name = "kafka", category = StrLookup.CATEGORY)
public class KafkaLookup implements StrLookup {
@Override
public String lookup(String key) {
return getFromKafka(key);
}
@Override
public String lookup(LogEvent event, String key) {
return getFromKafka(key);
}
private String getFromKafka(String topicName) {
//kafka search logic should go here
return "topic1-p1";
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/KafkaBroker.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/KafkaBroker.java | package com.baeldung.logging.log4j2.plugins;
import java.io.Serializable;
public class KafkaBroker implements Serializable {
private final String ipAddress;
private final int port;
public KafkaBroker(String ipAddress, int port, String topic, String partition) {
this.ipAddress = ipAddress;
this.port = port;
this.topic = topic;
this.partition = partition;
}
public String getTopic() {
return topic;
}
public String getPartition() {
return partition;
}
private final String topic;
private final String partition;
public String getIpAddress() {
return ipAddress;
}
public int getPort() {
return port;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/DockerPatternConverter.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/DockerPatternConverter.java | package com.baeldung.logging.log4j2.plugins;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.pattern.ConverterKeys;
import org.apache.logging.log4j.core.pattern.LogEventPatternConverter;
import org.apache.logging.log4j.core.pattern.PatternConverter;
@Plugin(name = "DockerPatternConverter", category = PatternConverter.CATEGORY)
@ConverterKeys({"docker", "container"})
public class DockerPatternConverter extends LogEventPatternConverter {
private DockerPatternConverter(String[] options) {
super("Docker", "docker");
}
public static DockerPatternConverter newInstance(String[] options) {
return new DockerPatternConverter(options);
}
@Override
public void format(LogEvent event, StringBuilder toAppendTo) {
toAppendTo.append(dockerContainer());
}
private String dockerContainer() {
//get docker container ID inside which application is running here
return "container-1";
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/KafkaAppender.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/plugins/KafkaAppender.java | package com.baeldung.logging.log4j2.plugins;
import org.apache.logging.log4j.core.Core;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.appender.AbstractAppender;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute;
import org.apache.logging.log4j.core.config.plugins.PluginBuilderFactory;
import org.apache.logging.log4j.core.config.plugins.PluginElement;
import org.apache.logging.log4j.core.config.plugins.validation.constraints.Required;
import java.io.Serializable;
@Plugin(name = "Kafka2", category = Core.CATEGORY_NAME)
public class KafkaAppender extends AbstractAppender {
@PluginBuilderFactory
public static Builder newBuilder() {
return new Builder();
}
public static class Builder implements org.apache.logging.log4j.core.util.Builder<KafkaAppender> {
@PluginBuilderAttribute("name")
@Required
private String name;
@PluginBuilderAttribute("ip")
private String ipAddress;
@PluginBuilderAttribute("port")
private int port;
@PluginBuilderAttribute("topic")
private String topic;
@PluginBuilderAttribute("partition")
private String partition;
@PluginElement("Layout")
private Layout<? extends Serializable> layout;
@PluginElement("Filter")
private Filter filter;
public Layout<? extends Serializable> getLayout() {
return layout;
}
public Builder setLayout(Layout<? extends Serializable> layout) {
this.layout = layout;
return this;
}
public Filter getFilter() {
return filter;
}
public String getName() {
return name;
}
public Builder setName(String name) {
this.name = name;
return this;
}
public Builder setFilter(Filter filter) {
this.filter = filter;
return this;
}
public String getIpAddress() {
return ipAddress;
}
public Builder setIpAddress(String ipAddress) {
this.ipAddress = ipAddress;
return this;
}
public int getPort() {
return port;
}
public Builder setPort(int port) {
this.port = port;
return this;
}
public String getTopic() {
return topic;
}
public Builder setTopic(String topic) {
this.topic = topic;
return this;
}
public String getPartition() {
return partition;
}
public Builder setPartition(String partition) {
this.partition = partition;
return this;
}
@Override
public KafkaAppender build() {
return new KafkaAppender(getName(), getFilter(), getLayout(), true, new KafkaBroker(ipAddress, port, topic, partition));
}
}
private KafkaBroker broker;
private KafkaAppender(String name, Filter filter, Layout<? extends Serializable> layout, boolean ignoreExceptions, KafkaBroker broker) {
super(name, filter, layout, ignoreExceptions);
this.broker = broker;
}
@Override
public void append(LogEvent event) {
connectAndSendToKafka(broker, event);
}
private void connectAndSendToKafka(KafkaBroker broker, LogEvent event) {
//send to Kafka
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/appender/MapAppender.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2/appender/MapAppender.java | /**
*
*/
package com.baeldung.logging.log4j2.appender;
import java.time.Instant;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.Core;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.appender.AbstractAppender;
import org.apache.logging.log4j.core.config.plugins.Plugin;
import org.apache.logging.log4j.core.config.plugins.PluginAttribute;
import org.apache.logging.log4j.core.config.plugins.PluginElement;
import org.apache.logging.log4j.core.config.plugins.PluginFactory;
@Plugin(name = "MapAppender", category = Core.CATEGORY_NAME, elementType = Appender.ELEMENT_TYPE)
public class MapAppender extends AbstractAppender {
private ConcurrentMap<String, LogEvent> eventMap = new ConcurrentHashMap<>();
protected MapAppender(String name, Filter filter) {
super(name, filter, null);
}
@PluginFactory
public static MapAppender createAppender(@PluginAttribute("name") String name, @PluginElement("Filter") final Filter filter) {
return new MapAppender(name, filter);
}
@Override
public void append(LogEvent event) {
if (event.getLevel()
.isLessSpecificThan(Level.WARN)) {
error("Unable to log less than WARN level.");
return;
}
eventMap.put(Instant.now()
.toString(), event);
}
public ConcurrentMap<String, LogEvent> getEventMap() {
return eventMap;
}
public void setEventMap(ConcurrentMap<String, LogEvent> eventMap) {
this.eventMap = eventMap;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/slf4j/SLF4JLogExceptions.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/slf4j/SLF4JLogExceptions.java | package com.baeldung.logging.slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class SLF4JLogExceptions {
public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger(SLF4JLogExceptions.class);
logger.error("An exception occurred!");
logger.error("An exception occurred!", new Exception("Custom exception"));
logger.error("{}, {}! An exception occurred!", "Hello", "World", new Exception("Custom exception"));
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2threadinfo/Log4j2ThreadInfo.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j2threadinfo/Log4j2ThreadInfo.java | package com.baeldung.logging.log4j2threadinfo;
import java.util.stream.IntStream;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class Log4j2ThreadInfo {
private static final Logger logger = LogManager.getLogger(Log4j2ThreadInfo.class);
public static void main(String[] args) {
IntStream.range(0, 5).forEach(i -> {
Runnable runnable = () -> logger.info("Logging info");
Thread thread = new Thread(runnable);
thread.start();
});
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j/NoAppenderExample.java | logging-modules/log4j2/src/main/java/com/baeldung/logging/log4j/NoAppenderExample.java | package com.baeldung.logging.log4j;
import org.apache.log4j.Logger;
public class NoAppenderExample {
private final static Logger logger = Logger.getLogger(NoAppenderExample.class);
public static void main(String[] args) {
//Setup default appender
//BasicConfigurator.configure();
//Define path to configuration file
//PropertyConfigurator.configure("src\\main\\resources\\log4j.properties");
logger.info("Info log message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/test/java/com/baeldung/ndc/NDCLogIntegrationTest.java | logging-modules/log-mdc/src/test/java/com/baeldung/ndc/NDCLogIntegrationTest.java | package com.baeldung.ndc;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import com.baeldung.config.AppConfiguration;
import com.fasterxml.jackson.databind.ObjectMapper;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = AppConfiguration.class)
@WebAppConfiguration
public class NDCLogIntegrationTest {
private MockMvc mockMvc;
@Autowired
private WebApplicationContext webApplicationContext;
private Investment investment;
@Before
public void setUp() {
mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
investment = new Investment();
investment.setTransactionId("123");
investment.setOwner("Mark");
investment.setAmount(1000L);
}
@Test
public void givenLog4jLogger_whenNDCAdded_thenResponseOkAndNDCInLog() throws Exception {
mockMvc.perform(post("/ndc/log4j", investment).contentType(MediaType.APPLICATION_JSON).content(new ObjectMapper().writeValueAsString(investment))).andExpect(status().is2xxSuccessful());
}
@Test
public void givenLog4j2Logger_whenNDCAdded_thenResponseOkAndNDCInLog() throws Exception {
mockMvc.perform(post("/ndc/log4j2", investment).contentType(MediaType.APPLICATION_JSON).content(new ObjectMapper().writeValueAsString(investment))).andExpect(status().is2xxSuccessful());
}
@Test
public void givenJBossLoggerBridge_whenNDCAdded_thenResponseOkAndNDCInLog() throws Exception {
mockMvc.perform(post("/ndc/jboss-logging", investment).contentType(MediaType.APPLICATION_JSON).content(new ObjectMapper().writeValueAsString(investment))).andExpect(status().is2xxSuccessful());
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/test/java/com/baeldung/mdc/log4j2/DemoIntegrationTest.java | logging-modules/log-mdc/src/test/java/com/baeldung/mdc/log4j2/DemoIntegrationTest.java | package com.baeldung.mdc.log4j2;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.apache.log4j.Logger;
import org.junit.Test;
import com.baeldung.mdc.TransactionFactory;
import com.baeldung.mdc.Transfer;
import com.baeldung.mdc.log4j.Log4JRunnable;
import com.baeldung.mdc.log4j2.Log4J2Runnable;
import com.baeldung.mdc.slf4j.Slf4jRunnable;
public class DemoIntegrationTest {
@Test
public void main() throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(3);
TransactionFactory transactionFactory = new TransactionFactory();
for (int i = 0; i < 10; i++) {
Transfer tx = transactionFactory.newInstance();
Runnable task = new Log4J2Runnable(tx);
executor.submit(task);
}
executor.shutdown();
executor.awaitTermination(60, TimeUnit.SECONDS);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/test/java/com/baeldung/mdc/slf4j/DemoIntegrationTest.java | logging-modules/log-mdc/src/test/java/com/baeldung/mdc/slf4j/DemoIntegrationTest.java | package com.baeldung.mdc.slf4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.apache.log4j.Logger;
import org.junit.Test;
import com.baeldung.mdc.TransactionFactory;
import com.baeldung.mdc.Transfer;
import com.baeldung.mdc.log4j.Log4JRunnable;
import com.baeldung.mdc.log4j2.Log4J2Runnable;
import com.baeldung.mdc.slf4j.Slf4jRunnable;
public class DemoIntegrationTest {
@Test
public void main() throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(3);
TransactionFactory transactionFactory = new TransactionFactory();
for (int i = 0; i < 10; i++) {
Transfer tx = transactionFactory.newInstance();
Runnable task = new Slf4jRunnable(tx);
executor.submit(task);
}
executor.shutdown();
executor.awaitTermination(60, TimeUnit.SECONDS);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/test/java/com/baeldung/mdc/log4j/DemoIntegrationTest.java | logging-modules/log-mdc/src/test/java/com/baeldung/mdc/log4j/DemoIntegrationTest.java | package com.baeldung.mdc.log4j;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import com.baeldung.mdc.TransactionFactory;
import com.baeldung.mdc.Transfer;
public class DemoIntegrationTest {
@Test
public void main() throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(3);
TransactionFactory transactionFactory = new TransactionFactory();
for (int i = 0; i < 10; i++) {
Transfer tx = transactionFactory.newInstance();
Runnable task = new Log4JRunnable(tx);
executor.submit(task);
}
executor.shutdown();
executor.awaitTermination(60, TimeUnit.SECONDS);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/Investment.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/Investment.java | package com.baeldung.ndc;
public class Investment {
private String transactionId;
private String owner;
private Long amount;
public Investment() {
}
public Investment(String transactionId, String owner, Long amount) {
this.transactionId = transactionId;
this.owner = owner;
this.amount = amount;
}
public String getTransactionId() {
return transactionId;
}
public void setTransactionId(String transactionId) {
this.transactionId = transactionId;
}
public String getOwner() {
return owner;
}
public void setOwner(String owner) {
this.owner = owner;
}
public Long getAmount() {
return amount;
}
public void setAmount(Long amount) {
this.amount = amount;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/controller/Log4JController.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/controller/Log4JController.java | package com.baeldung.ndc.controller;
import org.apache.log4j.NDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.baeldung.ndc.Investment;
import com.baeldung.ndc.service.InvestmentService;
@RestController
public class Log4JController {
@Autowired
@Qualifier("log4jInvestmentService")
private InvestmentService log4jBusinessService;
@RequestMapping(value = "/ndc/log4j", method = RequestMethod.POST)
public ResponseEntity<Investment> postPayment(@RequestBody Investment investment) {
// Add transactionId and owner to NDC
NDC.push("tx.id=" + investment.getTransactionId());
NDC.push("tx.owner=" + investment.getOwner());
try {
log4jBusinessService.transfer(investment.getAmount());
} finally {
// take out owner from the NDC stack
NDC.pop();
// take out transactionId from the NDC stack
NDC.pop();
NDC.remove();
}
return new ResponseEntity<Investment>(investment, HttpStatus.OK);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/controller/Log4J2Controller.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/controller/Log4J2Controller.java | package com.baeldung.ndc.controller;
import org.apache.logging.log4j.ThreadContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.baeldung.ndc.Investment;
import com.baeldung.ndc.service.InvestmentService;
@RestController
public class Log4J2Controller {
@Autowired
@Qualifier("log4j2InvestmentService")
private InvestmentService log4j2BusinessService;
@RequestMapping(value = "/ndc/log4j2", method = RequestMethod.POST)
public ResponseEntity<Investment> postPayment(@RequestBody Investment investment) {
// Add transactionId and owner to NDC
ThreadContext.push("tx.id=" + investment.getTransactionId());
ThreadContext.push("tx.owner=" + investment.getOwner());
try {
log4j2BusinessService.transfer(investment.getAmount());
} finally {
// take out owner from the NDC stack
ThreadContext.pop();
// take out transactionId from the NDC stack
ThreadContext.pop();
ThreadContext.clearAll();
}
return new ResponseEntity<Investment>(investment, HttpStatus.OK);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/controller/JBossLoggingController.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/controller/JBossLoggingController.java | package com.baeldung.ndc.controller;
import org.jboss.logging.NDC;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.baeldung.ndc.Investment;
import com.baeldung.ndc.service.InvestmentService;
@RestController
public class JBossLoggingController {
@Autowired
@Qualifier("JBossLoggingInvestmentService")
private InvestmentService jbossLoggingBusinessService;
@RequestMapping(value = "/ndc/jboss-logging", method = RequestMethod.POST)
public ResponseEntity<Investment> postPayment(@RequestBody Investment investment) {
// Add transactionId and owner to NDC
NDC.push("tx.id=" + investment.getTransactionId());
NDC.push("tx.owner=" + investment.getOwner());
try {
jbossLoggingBusinessService.transfer(investment.getAmount());
} finally {
// take out owner from the NDC stack
NDC.pop();
// take out transactionId from the NDC stack
NDC.pop();
NDC.clear();
}
return new ResponseEntity<Investment>(investment, HttpStatus.OK);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/JBossLoggingInvestmentService.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/JBossLoggingInvestmentService.java | package com.baeldung.ndc.service;
import org.jboss.logging.Logger;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
@Qualifier("JBossLoggingInvestmentService")
public class JBossLoggingInvestmentService implements InvestmentService {
private static final Logger logger = Logger.getLogger(JBossLoggingInvestmentService.class);
@Override
public void beforeTransfer(long amount) {
logger.infov("Preparing to transfer {0}$.", amount);
}
@Override
public void afterTransfer(long amount, boolean outcome) {
logger.infov("Has transfer of {0}$ completed successfully ? {1}.", amount, outcome);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/InvestmentService.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/InvestmentService.java | package com.baeldung.ndc.service;
/**
* A fake investment service.
*/
public interface InvestmentService {
/**
* Sample service transferring a given amount of money.
* @param amount
* @return {@code true} when the transfer complete successfully, {@code false} otherwise.
*/
default public boolean transfer(long amount) {
beforeTransfer(amount);
// exchange messages with a remote system to transfer the money
try {
// let's pause randomly to properly simulate an actual system.
Thread.sleep((long) (500 + Math.random() * 500));
} catch (InterruptedException e) {
// should never happen
}
// let's simulate both failing and successful transfers
boolean outcome = Math.random() >= 0.25;
afterTransfer(amount, outcome);
return outcome;
}
void beforeTransfer(long amount);
void afterTransfer(long amount, boolean outcome);
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/Log4JInvestmentService.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/Log4JInvestmentService.java | package com.baeldung.ndc.service;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
@Qualifier("log4jInvestmentService")
public class Log4JInvestmentService implements InvestmentService {
private Logger logger = Logger.getLogger(Log4JInvestmentService.class);
@Override
public void beforeTransfer(long amount) {
logger.info("Preparing to transfer " + amount + "$.");
}
@Override
public void afterTransfer(long amount, boolean outcome) {
logger.info("Has transfer of " + amount + "$ completed successfully ? " + outcome + ".");
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/Log4J2InvestmentService.java | logging-modules/log-mdc/src/main/java/com/baeldung/ndc/service/Log4J2InvestmentService.java | package com.baeldung.ndc.service;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
@Qualifier("log4j2InvestmentService")
public class Log4J2InvestmentService implements InvestmentService {
private static final Logger logger = LogManager.getLogger();
@Override
public void beforeTransfer(long amount) {
logger.info("Preparing to transfer {}$.", amount);
}
@Override
public void afterTransfer(long amount, boolean outcome) {
logger.info("Has transfer of {}$ completed successfully ? {}.", amount, outcome);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/TransferService.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/TransferService.java | package com.baeldung.mdc;
/**
* A fake transfer service simulating an actual one.
*/
public abstract class TransferService {
/** Sample service transferring a given amount of money.
* @return {@code true} when the transfer complete successfully, {@code false} otherwise. */
public boolean transfer(long amount) {
beforeTransfer(amount);
// exchange messages with a remote system to transfer the money
try {
// let's pause randomly to properly simulate an actual system.
Thread.sleep((long) (500 + Math.random() * 500));
} catch (InterruptedException e) {
// should never happen
}
// let's simulate both failing and successful transfers
boolean outcome = Math.random() >= 0.25;
afterTransfer(amount, outcome);
return outcome;
}
abstract protected void beforeTransfer(long amount);
abstract protected void afterTransfer(long amount, boolean outcome);
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/TransferDemo.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/TransferDemo.java | package com.baeldung.mdc;
import com.baeldung.mdc.pool.MdcAwareThreadPoolExecutor;
import com.baeldung.mdc.slf4j.Slf4jRunnable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
import static java.util.concurrent.TimeUnit.MINUTES;
public class TransferDemo {
public static void main(String[] args) {
ExecutorService executor = new MdcAwareThreadPoolExecutor(3, 3, 0, MINUTES,
new LinkedBlockingQueue<>(), Thread::new, new AbortPolicy());
TransactionFactory transactionFactory = new TransactionFactory();
for (int i = 0; i < 10; i++) {
Transfer tx = transactionFactory.newInstance();
// Runnable task = new Log4JRunnable(tx);
// Runnable task = new Log4J2Runnable(tx);
Runnable task = new Slf4jRunnable(tx);
executor.submit(task);
}
executor.shutdown();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/TransactionFactory.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/TransactionFactory.java | package com.baeldung.mdc;
import static java.lang.Math.floor;
import static java.lang.Math.random;
import java.util.UUID;
public class TransactionFactory {
private static final String[] NAMES = { "John", "Susan", "Marc", "Samantha" };
private static long nextId = 1;
public Transfer newInstance() {
String transactionId = String.valueOf(nextId++);
String owner = NAMES[(int) floor(random() * NAMES.length)];
long amount = (long) (random() * 1500 + 500);
Transfer tx = new Transfer(transactionId, owner, amount);
return tx;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/Transfer.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/Transfer.java | package com.baeldung.mdc;
public class Transfer {
private String transactionId;
private String sender;
private Long amount;
public Transfer(String transactionId, String sender, long amount) {
this.transactionId = transactionId;
this.sender = sender;
this.amount = amount;
}
public String getSender() {
return sender;
}
public String getTransactionId() {
return transactionId;
}
public Long getAmount() {
return amount;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j2/Log4J2TransferService.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j2/Log4J2TransferService.java | package com.baeldung.mdc.log4j2;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import com.baeldung.mdc.TransferService;
public class Log4J2TransferService extends TransferService {
private static final Logger logger = LogManager.getLogger();
@Override
protected void beforeTransfer(long amount) {
logger.info("Preparing to transfer {}$.", amount);
}
@Override
protected void afterTransfer(long amount, boolean outcome) {
logger.info("Has transfer of {}$ completed successfully ? {}.", amount, outcome);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j2/Log4J2Runnable.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j2/Log4J2Runnable.java | package com.baeldung.mdc.log4j2;
import org.apache.logging.log4j.ThreadContext;
import com.baeldung.mdc.Transfer;
public class Log4J2Runnable implements Runnable {
private final Transfer tx;
private Log4J2TransferService log4j2BusinessService = new Log4J2TransferService();
public Log4J2Runnable(Transfer tx) {
this.tx = tx;
}
public void run() {
ThreadContext.put("transaction.id", tx.getTransactionId());
ThreadContext.put("transaction.owner", tx.getSender());
log4j2BusinessService.transfer(tx.getAmount());
ThreadContext.clearAll();
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/pool/MdcAwareThreadPoolExecutor.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/pool/MdcAwareThreadPoolExecutor.java | package com.baeldung.mdc.pool;
import org.apache.logging.log4j.ThreadContext;
import org.slf4j.MDC;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class MdcAwareThreadPoolExecutor extends ThreadPoolExecutor {
public MdcAwareThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler) {
super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
}
@Override
protected void afterExecute(Runnable r, Throwable t) {
System.out.println("Cleaning the MDC context");
MDC.clear();
org.apache.log4j.MDC.clear();
ThreadContext.clearAll();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/slf4j/Slf4jRunnable.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/slf4j/Slf4jRunnable.java | package com.baeldung.mdc.slf4j;
import org.slf4j.MDC;
import com.baeldung.mdc.Transfer;
public class Slf4jRunnable implements Runnable {
private final Transfer tx;
public Slf4jRunnable(Transfer tx) {
this.tx = tx;
}
public void run() {
MDC.put("transaction.id", tx.getTransactionId());
MDC.put("transaction.owner", tx.getSender());
new Slf4TransferService().transfer(tx.getAmount());
// MDC.clear(); We don't need this with MdcAwareThreadPoolExecutor
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/slf4j/Slf4TransferService.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/slf4j/Slf4TransferService.java | package com.baeldung.mdc.slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.baeldung.mdc.TransferService;
final class Slf4TransferService extends TransferService {
private static final Logger logger = LoggerFactory.getLogger(Slf4TransferService.class);
@Override
protected void beforeTransfer(long amount) {
logger.info("Preparing to transfer {}$.", amount);
}
@Override
protected void afterTransfer(long amount, boolean outcome) {
logger.info("Has transfer of {}$ completed successfully ? {}.", amount, outcome);
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j/Log4JRunnable.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j/Log4JRunnable.java | package com.baeldung.mdc.log4j;
import org.apache.log4j.MDC;
import com.baeldung.mdc.Transfer;
public class Log4JRunnable implements Runnable {
private Transfer tx;
private static Log4JTransferService log4jBusinessService = new Log4JTransferService();
public Log4JRunnable(Transfer tx) {
this.tx = tx;
}
public void run() {
MDC.put("transaction.id", tx.getTransactionId());
MDC.put("transaction.owner", tx.getSender());
log4jBusinessService.transfer(tx.getAmount());
MDC.clear();
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j/Log4JTransferService.java | logging-modules/log-mdc/src/main/java/com/baeldung/mdc/log4j/Log4JTransferService.java | package com.baeldung.mdc.log4j;
import org.apache.log4j.Logger;
import com.baeldung.mdc.TransferService;
public class Log4JTransferService extends TransferService {
private Logger logger = Logger.getLogger(Log4JTransferService.class);
@Override
protected void beforeTransfer(long amount) {
logger.info("Preparing to transfer " + amount + "$.");
}
@Override
protected void afterTransfer(long amount, boolean outcome) {
logger.info("Has transfer of " + amount + "$ completed successfully ? " + outcome + ".");
}
} | java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/config/AppInitializer.java | logging-modules/log-mdc/src/main/java/com/baeldung/config/AppInitializer.java | package com.baeldung.config;
import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
super.onStartup(servletContext);
}
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[] { AppConfiguration.class };
}
@Override
protected Class<?>[] getServletConfigClasses() {
return null;
}
@Override
protected String[] getServletMappings() {
return new String[] { "/" };
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log-mdc/src/main/java/com/baeldung/config/AppConfiguration.java | logging-modules/log-mdc/src/main/java/com/baeldung/config/AppConfiguration.java | package com.baeldung.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.baeldung")
public class AppConfiguration implements WebMvcConfigurer {
public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
configurer.enable();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/Log4j2BaseIntegrationTest.java | logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/Log4j2BaseIntegrationTest.java | package com.baeldung.logging.log4j2;
import java.lang.reflect.Field;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.junit.AfterClass;
public class Log4j2BaseIntegrationTest {
@AfterClass
public static void tearDown() throws Exception {
Field factories = ConfigurationFactory.class.getDeclaredField("factories");
factories.setAccessible(true);
factories.set(null, null);
ConfigurationFactory.resetConfigurationFactory();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/DynamicFileAppenderUnitTest.java | logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/DynamicFileAppenderUnitTest.java | package com.baeldung.logging.log4j2;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import org.apache.log4j.xml.DOMConfigurator;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.config.Configurator;
import org.junit.jupiter.api.Test;
public class DynamicFileAppenderUnitTest {
@Test
public void givenLog4j2DynamicFileNameConfig_whenLogToFile_thenFileIsCreated() throws Exception {
System.setProperty("log4j.configurationFile", "src/test/resources/log4j2-dynamic.xml");
System.setProperty("logfilename", "app-dynamic-log");
Logger logger = LogManager.getLogger(DynamicFileAppenderUnitTest.class);
String expectedMessage = "This is an ERROR log message to the same file.";
logger.error(expectedMessage);
File file = new File("app-dynamic-log.log");
assertTrue(file.exists(), "Log file should be created dynamically.");
String content = Files.readString(file.toPath());
assertTrue(content.contains(expectedMessage), "Log file should contain the logged message.");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/CustomLoggingIntegrationTest.java | logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/CustomLoggingIntegrationTest.java | package com.baeldung.logging.log4j2;
import static org.junit.Assert.assertTrue;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.sql.Connection;
import java.sql.ResultSet;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.Marker;
import org.apache.logging.log4j.MarkerManager;
import org.apache.logging.log4j.ThreadContext;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
import com.baeldung.logging.log4j2.jdbc.ConnectionFactory;
@RunWith(JUnit4.class)
public class CustomLoggingIntegrationTest {
private static String logFilePath = System.getProperty("logging.folder.path");
@BeforeClass
public static void setup() throws Exception {
Connection connection = ConnectionFactory.getConnection();
connection.createStatement()
.execute("CREATE TABLE logs(" + "when TIMESTAMP," + "logger VARCHAR(255)," + "level VARCHAR(255)," + "message VARCHAR(4096)," + "throwable TEXT)");
connection.commit();
}
@Test
public void givenLoggerWithDefaultConfig_whenLogToConsole_thenOK() throws Exception {
Logger logger = LogManager.getLogger(getClass());
Exception e = new RuntimeException("This is only a test!");
logger.info("This is a simple message at INFO level. " + "It will be hidden.");
logger.error("This is a simple message at ERROR level. " + "This is the minimum visible level.", e);
}
@Test
public void givenLoggerWithConsoleConfig_whenLogToConsoleInColors_thenOK() throws Exception {
Logger logger = LogManager.getLogger("CONSOLE_PATTERN_APPENDER_MARKER");
Exception e = new RuntimeException("This is only a test!");
logger.trace("This is a colored message at TRACE level.");
logger.debug("This is a colored message at DEBUG level. " + "This is the minimum visible level.");
logger.info("This is a colored message at INFO level.");
logger.warn("This is a colored message at WARN level.");
logger.error("This is a colored message at ERROR level.", e);
logger.fatal("This is a colored message at FATAL level.");
}
@Test
public void givenLoggerWithConsoleConfig_whenFilterByMarker_thenOK() throws Exception {
Logger logger = LogManager.getLogger("CONSOLE_PATTERN_APPENDER_MARKER");
Marker appError = MarkerManager.getMarker("APP_ERROR");
Marker connectionTrace = MarkerManager.getMarker("CONN_TRACE");
logger.error(appError, "This marker message at ERROR level should be hidden.");
logger.trace(connectionTrace, "This is a marker message at TRACE level.");
}
@Test
public void givenLoggerWithConsoleConfig_whenFilterByThreadContext_thenOK() throws Exception {
Logger logger = LogManager.getLogger("CONSOLE_PATTERN_APPENDER_THREAD_CONTEXT");
ThreadContext.put("userId", "1000");
logger.info("This is a log-visible user login. Maybe from an admin account?");
ThreadContext.put("userId", "1001");
logger.info("This is a log-invisible user login.");
}
@Test
public void givenLoggerWithAsyncConfig_whenLogToJsonFile_thenOK() throws Exception {
Logger logger = LogManager.getLogger("ASYNC_JSON_FILE_APPENDER");
final int count = 88;
for (int i = 0; i < count; i++) {
logger.info("This is async JSON message #{} at INFO level.", count);
}
long logEventsCount = Files.lines(Paths.get(logFilePath))
.count();
assertTrue(logEventsCount >= 0 && logEventsCount <= count);
}
@Test
public void givenLoggerWithFailoverConfig_whenLog_thenOK() throws Exception {
Logger logger = LogManager.getLogger("FAIL_OVER_SYSLOG_APPENDER");
Exception e = new RuntimeException("This is only a test!");
logger.trace("This is a syslog message at TRACE level.");
logger.debug("This is a syslog message at DEBUG level.");
logger.info("This is a syslog message at INFO level. This is the minimum visible level.");
logger.warn("This is a syslog message at WARN level.");
logger.error("This is a syslog message at ERROR level.", e);
logger.fatal("This is a syslog message at FATAL level.");
}
@Test
public void givenLoggerWithJdbcConfig_whenLogToDataSource_thenOK() throws Exception {
Logger logger = LogManager.getLogger("JDBC_APPENDER");
final int count = 88;
for (int i = 0; i < count; i++) {
logger.info("This is JDBC message #{} at INFO level.", count);
}
Connection connection = ConnectionFactory.getConnection();
ResultSet resultSet = connection.createStatement()
.executeQuery("SELECT COUNT(*) AS ROW_COUNT FROM logs");
int logCount = 0;
if (resultSet.next()) {
logCount = resultSet.getInt("ROW_COUNT");
}
assertTrue(logCount <= count);
}
@Test
public void givenLoggerWithRollingFileConfig_whenLogToXMLFile_thenOK() throws Exception {
Logger logger = LogManager.getLogger("XML_ROLLING_FILE_APPENDER");
final int count = 88;
for (int i = 0; i < count; i++) {
logger.info("This is rolling file XML message #{} at INFO level.", i);
}
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/JSONLayoutIntegrationTest.java | logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/JSONLayoutIntegrationTest.java | package com.baeldung.logging.log4j2;
import static org.junit.Assert.assertTrue;
import java.io.CharArrayWriter;
import java.io.Writer;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.appender.WriterAppender;
import org.apache.logging.log4j.core.layout.JsonLayout;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JSONLayoutIntegrationTest extends Log4j2BaseIntegrationTest {
private Appender appender;
private Logger logger;
private final Writer writer = new CharArrayWriter();
@Before
public void setUp() {
logger = LogManager.getLogger("CONSOLE_JSON_APPENDER");
appender = WriterAppender.newBuilder()
.setTarget(writer)
.setLayout(JsonLayout.newBuilder().build())
.setName("json_layout_for_testing")
.build();
appender.start();
((org.apache.logging.log4j.core.Logger) logger).addAppender(appender);
}
@Test
public void whenLogLayoutInJSON_thenOutputIsCorrectJSON() throws Exception {
logger.debug("Debug message");
writer.flush();
assertTrue(isValidJSON(writer.toString()));
}
@After
public void cleanup() {
((org.apache.logging.log4j.core.Logger) logger).removeAppender(appender);
}
private static boolean isValidJSON(String jsonInString) throws Exception {
JsonNode jsonNode = new ObjectMapper().readTree(jsonInString);
return jsonNode.get("message").asText().equals("Debug message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/jdbc/ConnectionFactory.java | logging-modules/log4j/src/test/java/com/baeldung/logging/log4j2/jdbc/ConnectionFactory.java | package com.baeldung.logging.log4j2.jdbc;
import java.sql.Connection;
import java.sql.SQLException;
import org.apache.commons.dbcp2.BasicDataSource;
import org.h2.Driver;
public class ConnectionFactory {
private interface Singleton {
ConnectionFactory INSTANCE = new ConnectionFactory();
}
private BasicDataSource dataSource;
private ConnectionFactory() {
dataSource = new BasicDataSource();
dataSource.setDriver(new Driver());
dataSource.setUrl("jdbc:h2:mem:db;DB_CLOSE_DELAY=-1;NON_KEYWORDS=WHEN");
}
public static Connection getConnection() throws SQLException {
return Singleton.INSTANCE.dataSource.getConnection();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/log4j2/Log4j2Example.java | logging-modules/log4j/src/main/java/com/baeldung/log4j2/Log4j2Example.java | package com.baeldung.log4j2;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;
public class Log4j2Example {
private static final Logger logger = LogManager.getLogger(Log4j2Example.class);
public static void main(String[] args) {
logger.debug("Debug log message");
logger.info("Info log message");
logger.error("Error log message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/log4j2/Log4j2ConsoleAndFile.java | logging-modules/log4j/src/main/java/com/baeldung/log4j2/Log4j2ConsoleAndFile.java | package com.baeldung.log4j2;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class Log4j2ConsoleAndFile {
private static final Logger logger = LogManager.getLogger(Log4j2ConsoleAndFile.class);
// To enable the console and file appender, just rename the log4j2 file, under /src/main/resources, to log4j2.properties
// Reason: Having the log4j2.properties file overrides the log4j2.xml file, so that other appender classes would not work
public static void main(String[] args) {
logger.info("Hello World!");
logger.debug("Hello World!");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/log4j2/Log4j2RollingExample.java | logging-modules/log4j/src/main/java/com/baeldung/log4j2/Log4j2RollingExample.java | package com.baeldung.log4j2;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
public class Log4j2RollingExample {
private static final Logger logger = LogManager.getLogger(Log4j2RollingExample.class);
public static void main(String[] args) throws InterruptedException {
for(int i = 0; i<2000; i++){
logger.info("This is the {} time I say 'Hello World'.", i);
Thread.sleep(100);
}
LogManager.shutdown();
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/slf4j/Slf4jRollingExample.java | logging-modules/log4j/src/main/java/com/baeldung/slf4j/Slf4jRollingExample.java | package com.baeldung.slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.stream.IntStream;
public class Slf4jRollingExample {
private static Logger logger = LoggerFactory.getLogger(Slf4jRollingExample.class);
public static void main(String[] args) throws InterruptedException {
for(int i = 0; i<2000; i++){
logger.info("This is the {} time I say 'Hello World'.", i);
Thread.sleep(100);
}
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/slf4j/Slf4jExample.java | logging-modules/log4j/src/main/java/com/baeldung/slf4j/Slf4jExample.java | package com.baeldung.slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* To switch between logging frameworks you need only to uncomment needed framework dependencies in pom.xml
*/
public class Slf4jExample {
private static Logger logger = LoggerFactory.getLogger(Slf4jExample.class);
public static void main(String[] args) {
logger.debug("Debug log message");
logger.info("Info log message");
logger.error("Error log message");
String variable = "Hello John";
logger.debug("Printing variable value {} ", variable);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/log4j/Log4jRollingExample.java | logging-modules/log4j/src/main/java/com/baeldung/log4j/Log4jRollingExample.java | package com.baeldung.log4j;
import java.util.stream.IntStream;
import org.apache.log4j.Logger;
public class Log4jRollingExample {
private final static Logger logger = Logger.getLogger(Log4jRollingExample.class);
public static void main(String[] args) throws InterruptedException {
for(int i = 0; i<2000; i++){
logger.info("This is the " + i + " time I say 'Hello World'.");
Thread.sleep(100);
}
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/log4j/Log4jExample.java | logging-modules/log4j/src/main/java/com/baeldung/log4j/Log4jExample.java | package com.baeldung.log4j;
import org.apache.log4j.Logger;
public class Log4jExample {
private final static Logger logger = Logger.getLogger(Log4jExample.class);
public static void main(String[] args) {
logger.trace("Trace log message");
logger.debug("Debug log message");
logger.info("Info log message");
logger.error("Error log message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/logback/LogbackRollingExample.java | logging-modules/log4j/src/main/java/com/baeldung/logback/LogbackRollingExample.java | package com.baeldung.logback;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.stream.IntStream;
public class LogbackRollingExample {
private static final Logger logger = LoggerFactory.getLogger(LogbackRollingExample.class);
public static void main(String[] args) throws InterruptedException {
for(int i = 0; i<2000; i++){
logger.info("This is the {} time I say 'Hello World'.", i);
Thread.sleep(100);
}
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/log4j/src/main/java/com/baeldung/logback/LogbackExample.java | logging-modules/log4j/src/main/java/com/baeldung/logback/LogbackExample.java | package com.baeldung.logback;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class LogbackExample {
private static final Logger logger = LoggerFactory.getLogger(LogbackExample.class);
public static void main(String[] args) {
logger.debug("Debug log message");
logger.info("Info log message");
logger.error("Error log message");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/flogger/src/test/java/com/baeldung/flogger/FloggerIntegrationTest.java | logging-modules/flogger/src/test/java/com/baeldung/flogger/FloggerIntegrationTest.java | package com.baeldung.flogger;
import com.google.common.flogger.FluentLogger;
import com.google.common.flogger.LoggerConfig;
import com.google.common.flogger.StackSize;
import org.junit.Test;
import java.util.logging.Level;
import java.util.stream.IntStream;
import static com.google.common.flogger.LazyArgs.lazy;
public class FloggerIntegrationTest {
static {
// System.setProperty("flogger.backend_factory", "com.google.common.flogger.backend.log4j.Log4jBackendFactory#getInstance");
System.setProperty("flogger.backend_factory", "com.google.common.flogger.backend.slf4j.Slf4jBackendFactory#getInstance");
}
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
@Test
public void givenAnInterval_shouldLogAfterEveryInterval() {
IntStream.range(0, 100).forEach(value -> {
logger.atInfo().every(40).log("This log shows [every 40 iterations] => %d", value);
});
}
@Test
public void givenAnObject_shouldLogTheObject() {
User user = new User();
logger.atInfo().log("The user is: %s", user); //correct
//The following ways of logging are not recommended
logger.atInfo().log("The user is: %s", user.toString());
logger.atInfo().log("The user is: %s" + user);
}
@Test
public void givenASimpleOperation_shouldLogTheResult() {
int result = 45 / 3;
logger.atInfo().log("The result is %d", result);
}
@Test
public void givenCodeThatThrowsAndException_shouldLogTheException() {
try {
int result = 45 / 0;
} catch (RuntimeException re) {
logger.atInfo().withStackTrace(StackSize.FULL).withCause(re).log("Message");
}
}
@Test
public void givenALoggingConfiguration_shouldLogAtTheConfiguredLevel() {
LoggerConfig.of(logger).setLevel(Level.FINE);
logger.atInfo().log("Info Message");
logger.atWarning().log("Warning Message");
logger.atSevere().log("Severe Message");
logger.atFinest().log("Finest Message");
logger.atFine().log("Fine Message");
logger.atFiner().log("Finer Message");
logger.atConfig().log("Config Message");
}
@Test
public void givenALongRunningMethodForStats_shouldCallTheMethodLazily() {
//Wrong way of doing it
logger.atFine().log("stats=%s", collectSummaries());
// Almost no work done at the log site and structure is preserved.
logger.atFine().log("stats=%s", lazy(() -> collectSummaries()));
}
public static String collectSummaries() {
//compute summaries in a long-running process
int items = 110;
int s = 30;
return String.format("%d seconds elapsed so far. %d items pending processing", s, items);
}
private class User {
String name = "Test";
@Override
public String toString() {
return name;
}
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/flogger/src/test/java/com/baeldung/flogger/FloggerManualTest.java | logging-modules/flogger/src/test/java/com/baeldung/flogger/FloggerManualTest.java | package com.baeldung.flogger;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
import org.junit.Test;
import com.google.common.flogger.FluentLogger;
public class FloggerManualTest {
static {
// System.setProperty("flogger.backend_factory", "com.google.common.flogger.backend.log4j.Log4jBackendFactory#getInstance");
System.setProperty("flogger.backend_factory",
"com.google.common.flogger.backend.slf4j.Slf4jBackendFactory#getInstance");
}
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
@Test
public void givenATimeInterval_shouldLogAfterEveryTimeInterval() {
IntStream.range(0, 1_000_0000).forEach(value -> {
logger.atInfo().atMostEvery(10, TimeUnit.SECONDS).log("This log shows [every 10 seconds] => %d", value);
});
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/flogger/src/main/java/com/baeldung/flogger/FloggerExamples.java | logging-modules/flogger/src/main/java/com/baeldung/flogger/FloggerExamples.java | package com.baeldung.flogger;
import com.google.common.flogger.FluentLogger;
import com.google.common.flogger.LoggerConfig;
import java.util.logging.Level;
public class FloggerExamples {
private static final FluentLogger logger = FluentLogger.forEnclosingClass();
public static void main(String[] args) {
LoggerConfig.of(logger).setLevel(Level.FINE);
Exception exception = new Exception("This is a test exception.");
logger.atInfo().withCause(exception).log("Log message with: %s", "Alfred");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logging-techniques/src/test/java/StructuredLog4jExampleUnitTest.java | logging-modules/logging-techniques/src/test/java/StructuredLog4jExampleUnitTest.java |
import com.baeldung.structuredlogging.User;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static net.logstash.logback.argument.StructuredArguments.kv;
public class StructuredLog4jExampleUnitTest {
Logger logger = LoggerFactory.getLogger("logger_name_example");
@Test
void whenInfoLoggingData_thenFormatItCorrectly() {
User user = new User("1", "John Doe", "123456");
logger.atInfo().setMessage("Processed user succesfully")
.addKeyValue("user_info", user)
.log();
}
@Test
void givenStructuredLog_whenUseLog4j_thenExtractCorrectInformation() {
User user = new User("1", "John Doe", "123456");
try {
throwExceptionMethod();
} catch (RuntimeException ex) {
logger.atError().addKeyValue("user_info", user)
.setMessage("Error processing given user")
.addKeyValue("exception_class", ex.getClass().getSimpleName())
.addKeyValue("error_message", ex.getMessage())
.log();
}
}
private void throwExceptionMethod() {
throw new RuntimeException("Error saving user data", new AssertionError());
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logging-techniques/src/test/java/com/baeldung/logging/LoggerBreakUnitTest.java | logging-modules/logging-techniques/src/test/java/com/baeldung/logging/LoggerBreakUnitTest.java | package com.baeldung.logging;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.core.read.ListAppender;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
class LoggerBreakUnitTest {
private Logger logger;
private ListAppender<ILoggingEvent> listAppender;
@BeforeEach
void setUp() {
logger = (Logger) LoggerFactory.getLogger(LoggerBreakUnitTest.class);
logger.setLevel(Level.INFO);
listAppender = new ListAppender<>();
listAppender.start();
logger.addAppender(listAppender);
}
@Test
void givenLogMessage_whenEmptyLineLogged_thenLogContainsBlankEntry() {
logger.info("Start process");
logger.info("");
List<ILoggingEvent> logs = listAppender.list;
assertEquals(2, logs.size());
assertEquals("Start process", logs.get(0)
.getFormattedMessage());
assertEquals("", logs.get(1)
.getFormattedMessage());
}
@Test
void givenLogMessage_whenUsingSystemLineSeparator_thenLogContainsPlatformSpecificLineBreak() {
logger.info("Processing done{}", System.lineSeparator());
List<ILoggingEvent> logs = listAppender.list;
assertEquals(1, logs.size());
assertTrue(logs.get(0)
.getFormattedMessage()
.endsWith(System.lineSeparator()));
}
@Test
void givenLogMessage_whenLineBreakIsConcatenated_thenLogSplitsCorrectly() {
logger.info("Processing done" + System.lineSeparator());
List<ILoggingEvent> logs = listAppender.list;
assertEquals(1, logs.size());
assertTrue(logs.get(0)
.getFormattedMessage()
.endsWith(System.lineSeparator()));
}
@Test
void givenLineSeparator_whenAppendedToLogMessages_thenLogEndsWithCorrectLineBreak() {
String newline = System.getProperty("line.separator");
logger.info("Processing started" + newline);
logger.info("Processing ended");
List<ILoggingEvent> logs = listAppender.list;
assertEquals(2, logs.size());
String firstMessage = logs.get(0)
.getFormattedMessage();
String secondMessage = logs.get(1)
.getFormattedMessage();
assertTrue(firstMessage.endsWith(newline), "First message should end with the system line separator");
assertEquals("Processing ended", secondMessage);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logging-techniques/src/main/java/com/baeldung/structuredlogging/User.java | logging-modules/logging-techniques/src/main/java/com/baeldung/structuredlogging/User.java | package com.baeldung.structuredlogging;
public class User {
private String id;
private String name;
private String password;
public User(String id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logback/src/test/java/com/baeldung/logback/LogbackPropertiesUnitTest.java | logging-modules/logback/src/test/java/com/baeldung/logback/LogbackPropertiesUnitTest.java | package com.baeldung.logback;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.io.File;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
public class LogbackPropertiesUnitTest {
private static LoggerContext loggerContext;
@BeforeAll
public static void setUp() {
System.setProperty("logback.configurationFile", "src/test/resources/logback-properties.xml");
loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
}
@Test
public void whenUserPropertiesFile_thenReturnCorrectLevel() {
Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
assertEquals(Level.INFO, rootLogger.getLevel());
Logger baeldungLogger = loggerContext.getLogger("com.baeldung.logback");
assertEquals(Level.DEBUG, baeldungLogger.getLevel());
Logger baeldungServicesLogger = loggerContext.getLogger("com.baeldung.logback.services");
assertEquals(Level.ERROR, baeldungServicesLogger.getLevel());
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logback/src/test/java/com/baeldung/logback/ConditionalLoggingUnitTest.java | logging-modules/logback/src/test/java/com/baeldung/logback/ConditionalLoggingUnitTest.java | package com.baeldung.logback;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import org.apache.commons.io.FileUtils;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.slf4j.LoggerFactory;
import ch.qos.logback.classic.Logger;
public class ConditionalLoggingUnitTest {
private static Logger logger;
private static ByteArrayOutputStream consoleOutput = new ByteArrayOutputStream();
private static PrintStream printStream = new PrintStream(consoleOutput);
@BeforeAll
public static void setUp() {
System.setProperty("logback.configurationFile", "src/test/resources/logback-conditional.xml");
// Redirect console output to our stream
System.setOut(printStream);
}
@Test
public void whenSystemPropertyIsNotPresent_thenReturnConsoleLogger() {
System.clearProperty("ENVIRONMENT");
logger = (Logger) LoggerFactory.getLogger(ConditionalLoggingUnitTest.class);
logger.info("test console log");
String logOutput = consoleOutput.toString();
assertTrue(logOutput.contains("test console log"));
}
@Test
public void whenSystemPropertyIsPresent_thenReturnFileLogger() throws IOException {
System.setProperty("ENVIRONMENT", "PROD");
logger = (Logger) LoggerFactory.getLogger(ConditionalLoggingUnitTest.class);
logger.info("test prod log");
String logOutput = FileUtils.readFileToString(new File("conditional.log"));
assertTrue(logOutput.contains("test prod log"));
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderIntegrationTest.java | logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderIntegrationTest.java | package com.baeldung.logback;
import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.spi.ILoggingEvent;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.LoggerFactory;
import java.util.List;
import static java.util.stream.Collectors.toList;
import static org.hamcrest.Matchers.hasItems;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThat;
public class MapAppenderIntegrationTest {
private Logger logger;
@Before
public void setUp() {
logger = (Logger) LoggerFactory.getLogger(MapAppenderIntegrationTest.class);
}
@Test
public void whenLoggerEmitsLoggingEvent_thenAppenderReceivesEvent() {
logger.info("Test from {}", this.getClass().getSimpleName());
MapAppender appender = (MapAppender) logger.getAppender("map");
List<String> messages = appender.getEventMap().values().stream().map(ILoggingEvent::getMessage).collect(toList());
assertThat(messages, hasItems("Test from {}"));
}
@Test
public void givenNoPrefixSet_whenLoggerEmitsEvent_thenAppenderReceivesNoEvent() {
logger.info("Test from {}", this.getClass().getSimpleName());
MapAppender appender = (MapAppender) logger.getAppender("badMap");
assertEquals(appender.getEventMap().size(), 0);
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logback/src/test/java/com/baeldung/logback/LogbackIntegrationTest.java | logging-modules/logback/src/test/java/com/baeldung/logback/LogbackIntegrationTest.java | package com.baeldung.logback;
import ch.qos.logback.classic.Level;
import org.junit.Test;
import ch.qos.logback.classic.Logger;
import org.slf4j.LoggerFactory;
public class LogbackIntegrationTest {
@Test
public void givenLogHierarchy_MessagesFiltered() {
ch.qos.logback.classic.Logger parentLogger =
(ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.baeldung.logback");
parentLogger.setLevel(Level.INFO);
Logger childlogger = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger("com.baeldung.logback.tests");
parentLogger.warn("This message is logged because WARN > INFO.");
// This request is disabled, because DEBUG < INFO.
parentLogger.debug("This message is not logged because DEBUG < INFO.");
childlogger.info("INFO == INFO");
childlogger.debug("DEBUG < INFO");
}
@Test
public void givenRootLevel_MessagesFiltered() {
ch.qos.logback.classic.Logger logger =
(ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.baeldung.logback");
logger.debug("Hi there!");
Logger rootLogger = (ch.qos.logback.classic.Logger)LoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME);
logger.debug("This message is logged because DEBUG == DEBUG.");
rootLogger.setLevel(Level.ERROR);
logger.warn("This message is not logged because WARN < ERROR.");
logger.error("This is logged.");
}
@Test
public void givenParameters_ValuesLogged() {
Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger(LogbackIntegrationTest.class);
String message = "This is a String";
Integer zero = 0;
try {
logger.debug("Logging message: {}", message);
logger.debug("Going to divide {} by {}", 42, zero);
int result = 42 / zero;
} catch (Exception e) {
logger.error("Error dividing {} by {} ", 42, zero, e);
}
}
@Test
public void givenConfig_MessageFiltered() {
Logger foobar = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.baeldung.foobar");
Logger logger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.baeldung.logback");
Logger testslogger = (ch.qos.logback.classic.Logger) LoggerFactory.getLogger("com.baeldung.logback.tests");
foobar.debug("This is logged from foobar");
logger.debug("This is not logged from logger");
logger.info("This is logged from logger");
testslogger.info("This is not logged from tests");
testslogger.warn("This is logged from tests");
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logback/src/test/java/com/baeldung/logback/JSONLayoutIntegrationTest.java | logging-modules/logback/src/test/java/com/baeldung/logback/JSONLayoutIntegrationTest.java | package com.baeldung.logback;
import static org.junit.Assert.assertTrue;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JSONLayoutIntegrationTest {
private static Logger logger;
private static Logger jsonlogger;
private ByteArrayOutputStream consoleOutput = new ByteArrayOutputStream();
private PrintStream ps = new PrintStream(consoleOutput);
@Before
public void setUp() {
// Redirect console output to our stream
System.setOut(ps);
}
@Test
public void givenJsonLayout_whenLogInJSON_thenOutputIsCorrectJSON() {
logger = LoggerFactory.getLogger("jsonLogger");
logger.debug("Debug message");
String currentLog = consoleOutput.toString();
assertTrue(!currentLog.isEmpty() && isValidJSON(currentLog));
}
@Test
public void givenJsonEncoder_whenLogInJSON_thenOutputIsCorrectJSON() {
jsonlogger = LoggerFactory.getLogger("jsonEncoderLogger");
jsonlogger.debug("Debug message");
String currentLog = consoleOutput.toString();
assertTrue(!currentLog.isEmpty() && isValidJSON(currentLog));
}
public static boolean isValidJSON(String jsonInString) {
try {
final ObjectMapper mapper = new ObjectMapper();
mapper.readTree(jsonInString);
return true;
} catch (IOException e) {
return false;
}
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
eugenp/tutorials | https://github.com/eugenp/tutorials/blob/4463e58ffb73fe599bac2479abd84598c6e70a1a/logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderUnitTest.java | logging-modules/logback/src/test/java/com/baeldung/logback/MapAppenderUnitTest.java | package com.baeldung.logback;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.spi.LoggingEvent;
import ch.qos.logback.core.BasicStatusManager;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
public class MapAppenderUnitTest {
private LoggerContext ctx;
private MapAppender mapAppender = new MapAppender();
private LoggingEvent event;
@Before
public void setUp() throws Exception {
ctx = new LoggerContext();
ctx.setName("test context");
ctx.setStatusManager(new BasicStatusManager());
mapAppender.setContext(ctx);
mapAppender.setPrefix("prefix");
event = new LoggingEvent("fqcn", ctx.getLogger("logger"), Level.INFO, "Test message for logback appender", null, new Object[0]);
ctx.start();
}
@After
public void tearDown() throws Exception {
ctx.stop();
mapAppender.stop();
}
@Test
public void whenPrefixIsNull_thenMapAppenderDoesNotLog() throws Exception {
mapAppender.setPrefix(null);
mapAppender.append(event);
assertTrue(mapAppender.getEventMap().isEmpty());
}
@Test
public void whenPrefixIsEmpty_thenMapAppenderDoesNotLog() throws Exception {
mapAppender.setPrefix("");
mapAppender.append(event);
assertTrue(mapAppender.getEventMap().isEmpty());
}
@Test
public void whenLogMessageIsEmitted_thenMapAppenderReceivesMessage() throws Exception {
mapAppender.append(event);
assertEquals(mapAppender.getEventMap().size(), 1);
mapAppender.getEventMap().forEach((k, v) -> assertTrue(k.startsWith("prefix")));
}
}
| java | MIT | 4463e58ffb73fe599bac2479abd84598c6e70a1a | 2026-01-04T14:45:57.069771Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.