Karate DSL for API Testing in Java

Introduction

Karate is a powerful open-source tool that combines API test automation, performance testing, and mocks into a single framework. Unlike traditional testing frameworks, Karate uses a behavior-driven development (BDD) syntax that makes tests readable and maintainable.

Setup and Dependencies

1. Maven Configuration

<properties>
<karate.version>1.4.1</karate.version>
<maven.surefire.version>3.0.0-M9</maven.surefire.version>
</properties>
<dependencies>
<!-- Karate Core -->
<dependency>
<groupId>com.intuit.karate</groupId>
<artifactId>karate-core</artifactId>
<version>${karate.version}</version>
<scope>test</scope>
</dependency>
<!-- Karate JUnit 5 -->
<dependency>
<groupId>com.intuit.karate</groupId>
<artifactId>karate-junit5</artifactId>
<version>${karate.version}</version>
<scope>test</scope>
</dependency>
<!-- Karate Apache - for HTTP client -->
<dependency>
<groupId>com.intuit.karate</groupId>
<artifactId>karate-apache</artifactId>
<version>${karate.version}</version>
<scope>test</scope>
</dependency>
<!-- Test Containers for integration testing -->
<dependency>
<groupId>org.testcontainers</groupId>
<artifactId>testcontainers</artifactId>
<version>1.19.3</version>
<scope>test</scope>
</dependency>
<!-- Rest Assured for comparison (optional) -->
<dependency>
<groupId>io.rest-assured</groupId>
<artifactId>rest-assured</artifactId>
<version>5.3.2</version>
<scope>test</scope>
</dependency>
<!-- Jackson for JSON parsing -->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.15.2</version>
</dependency>
</dependencies>
<build>
<testResources>
<testResource>
<directory>src/test/java</directory>
<excludes>
<exclude>**/*.java</exclude>
</excludes>
</testResource>
<testResource>
<directory>src/test/resources</directory>
</testResource>
</testResources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>${maven.surefire.version}</version>
<configuration>
<includes>
<include>**/*Test.java</include>
<include>**/*TestRunner.java</include>
</includes>
</configuration>
</plugin>
</plugins>
</build>

2. Gradle Configuration

dependencies {
testImplementation("com.intuit.karate:karate-core:1.4.1")
testImplementation("com.intuit.karate:karate-junit5:1.4.1")
testImplementation("com.intuit.karate:karate-apache:1.4.1")
testImplementation("org.testcontainers:testcontainers:1.19.3")
testImplementation("io.rest-assured:rest-assured:5.3.2")
}
sourceSets {
test {
resources {
srcDir file('src/test/java')
exclude '**/*.java'
}
}
}
test {
useJUnitPlatform()
systemProperty "karate.options", System.getProperty("karate.options")
systemProperty "karate.env", System.getProperty("karate.env", "dev")
outputs.upToDateWhen { false }
}

Project Structure

src/test/java/
├── com/example/tests/
│   ├── runners/
│   │   ├── TestRunner.java
│   │   ├── UserTestRunner.java
│   │   └── OrderTestRunner.java
│   ├── helpers/
│   │   ├── JavaHelpers.java
│   │   └── DatabaseUtils.java
│   └── utils/
│       ├── TestDataGenerator.java
│       └── EmailValidator.java
└── com/example/features/
├── common/
│   ├── common.feature
│   ├── headers.feature
│   └── auth.feature
├── users/
│   ├── users.feature
│   ├── user-create.feature
│   └── user-get.feature
├── orders/
│   ├── orders.feature
│   ├── order-create.feature
│   └── order-update.feature
├── payments/
│   └── payments.feature
└── performance/
└── load-test.feature

Core Karate Features

1. Basic API Test Structure

# users/user-create.feature
Feature: User Management API - Create User
Background:
* url baseUrl
* configure headers = { 'Content-Type': 'application/json', 'X-Request-ID': '#(requestId)' }
* def requestId = function() { return java.util.UUID.randomUUID() + '' }
Scenario: Create a new user with valid data
Given path 'users'
And request
"""
{
"firstName": "John",
"lastName": "Doe",
"email": "[email protected]",
"phone": "+1234567890",
"dateOfBirth": "1990-01-01"
}
"""
When method post
Then status 201
And match response ==
"""
{
"id": "#number",
"firstName": "John",
"lastName": "Doe",
"email": "[email protected]",
"phone": "+1234567890",
"dateOfBirth": "1990-01-01",
"createdAt": "#notnull",
"updatedAt": "#notnull"
}
"""
And def userId = response.id
Scenario: Create user with duplicate email should fail
Given path 'users'
And request
"""
{
"firstName": "Jane",
"lastName": "Smith",
"email": "[email protected]",
"phone": "+1234567891"
}
"""
When method post
Then status 409
And match response ==
"""
{
"errorCode": "USER_ALREADY_EXISTS",
"message": "#string",
"timestamp": "#notnull"
}
"""
Scenario: Create user with invalid email format
Given path 'users'
And request
"""
{
"firstName": "Invalid",
"lastName": "Email",
"email": "invalid-email",
"phone": "+1234567892"
}
"""
When method post
Then status 400
And match response.errorCode == 'VALIDATION_ERROR'
And match response.errors contains 'email'

2. Data-Driven Testing

# users/user-create-datadriven.feature
Feature: User Creation - Data Driven Tests
Background:
* url baseUrl
* configure headers = { 'Content-Type': 'application/json' }
Scenario Outline: Create user with various data combinations
Given path 'users'
And request
"""
{
"firstName": "<firstName>",
"lastName": "<lastName>",
"email": "<email>",
"phone": "<phone>"
}
"""
When method post
Then status <expectedStatus>
And match response <expectedResponse>
Examples:
| firstName | lastName | email               | phone       | expectedStatus | expectedResponse                      |
| John      | Doe      | [email protected]    | +1234567890 | 201            | { id: '#number', email: '[email protected]' } |
| Jane      | Smith    | invalid-email       | +1234567891 | 400            | { errorCode: 'VALIDATION_ERROR' }     |
|           | Johnson  | [email protected]     | +1234567892 | 400            | { errorCode: 'VALIDATION_ERROR' }     |
| Alice     |          | [email protected]   | +1234567893 | 400            | { errorCode: 'VALIDATION_ERROR' }     |
| Bob       | Brown    | [email protected]    | +1234567894 | 409            | { errorCode: 'USER_ALREADY_EXISTS' }  |
Scenario: Create multiple users from JSON array
* def users = read('classpath:com/example/features/users/test-data/users.json')
* def results = []
* eval for(var i = 0; i < users.length; i++)
"""
var user = users[i];
karate.call('user-create-single.feature', { userData: user });
results.push(response);
"""
* match each results contains { id: '#number', status: 'ACTIVE' }

3. Complex Test Scenarios

# orders/order-workflow.feature
Feature: Complete Order Workflow
Background:
* url baseUrl
* configure headers = { 'Content-Type': 'application/json' }
* def createUser = read('classpath:com/example/features/common/create-user.feature')
* def createProduct = read('classpath:com/example/features/common/create-product.feature')
Scenario: Complete order placement and payment workflow
# Step 1: Create a user
Given call createUser { firstName: 'Order', lastName: 'User', email: '[email protected]' }
And def userId = response.id
# Step 2: Create products
Given call createProduct { name: 'Test Product 1', price: 29.99, stock: 10 }
And def productId1 = response.id
Given call createProduct { name: 'Test Product 2', price: 49.99, stock: 5 }
And def productId2 = response.id
# Step 3: Create order
Given path 'orders'
And request
"""
{
"userId": "#(userId)",
"items": [
{
"productId": "#(productId1)",
"quantity": 2
},
{
"productId": "#(productId2)", 
"quantity": 1
}
],
"shippingAddress": {
"street": "123 Main St",
"city": "New York",
"state": "NY",
"zipCode": "10001",
"country": "USA"
}
}
"""
When method post
Then status 201
And def orderId = response.id
And match response.status == 'PENDING'
And match response.totalAmount == 109.97
# Step 4: Process payment
Given path 'payments'
And request
"""
{
"orderId": "#(orderId)",
"paymentMethod": "CREDIT_CARD",
"amount": 109.97,
"cardDetails": {
"number": "4111111111111111",
"expiryMonth": "12",
"expiryYear": "2025",
"cvv": "123"
}
}
"""
When method post
Then status 201
And def paymentId = response.id
And match response.status == 'COMPLETED'
# Step 5: Verify order status updated
Given path 'orders', orderId
When method get
Then status 200
And match response.status == 'CONFIRMED'
# Step 6: Verify inventory updated
Given path 'products', productId1
When method get
Then status 200
And match response.stock == 8
Given path 'products', productId2
When method get
Then status 200
And match response.stock == 4

Java Integration and Helpers

1. Test Runner Classes

package com.example.tests.runners;
import com.intuit.karate.junit5.Karate;
class TestRunner {
@Karate.Test
Karate testAll() {
return Karate.run().relativeTo(getClass());
}
@Karate.Test
Karate testUsers() {
return Karate.run("classpath:com/example/features/users")
.tags("@users")
.outputCucumberJson(true);
}
@Karate.Test
Karate testOrders() {
return Karate.run("classpath:com/example/features/orders")
.tags("@orders")
.outputHtmlReport(true);
}
@Karate.Test
Karate testPerformance() {
return Karate.run("classpath:com/example/features/performance")
.tags("@performance")
.outputJunitXml(true);
}
}
// Parallel Test Runner
package com.example.tests.runners;
import com.intuit.karate.Results;
import com.intuit.karate.Runner;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
class ParallelRunner {
@Test
void testParallel() {
Results results = Runner.path("classpath:com/example/features")
.tags("~@ignore")
.outputCucumberJson(true)
.outputHtmlReport(true)
.outputJunitXml(true)
.reportDir("target/karate-reports")
.parallel(5);
assertEquals(0, results.getFailCount(), results.getErrorMessages());
}
}

2. Java Helper Classes

package com.example.tests.helpers;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.UUID;
public class JavaHelpers {
private static final ObjectMapper objectMapper = new ObjectMapper();
public static String generateUniqueEmail() {
String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMddHHmmssSSS"));
return "testuser_" + timestamp + "@example.com";
}
public static String generateRandomString(int length) {
return UUID.randomUUID().toString().replace("-", "").substring(0, length);
}
public static Map<String, Object> createUserPayload(String firstName, String lastName, String email) {
ObjectNode payload = objectMapper.createObjectNode();
payload.put("firstName", firstName);
payload.put("lastName", lastName);
payload.put("email", email);
payload.put("phone", "+1" + generateRandomString(10));
payload.put("dateOfBirth", "1990-01-01");
return objectMapper.convertValue(payload, Map.class);
}
public static Map<String, Object> createOrderPayload(String userId, List<Map<String, Object>> items) {
ObjectNode payload = objectMapper.createObjectNode();
payload.put("userId", userId);
payload.set("items", objectMapper.valueToTree(items));
ObjectNode address = objectMapper.createObjectNode();
address.put("street", "123 Test St");
address.put("city", "Test City");
address.put("state", "TC");
address.put("zipCode", "12345");
address.put("country", "Testland");
payload.set("shippingAddress", address);
return objectMapper.convertValue(payload, Map.class);
}
public static boolean isValidEmail(String email) {
return email != null && email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
}
public static void waitForCondition(int maxWaitSeconds, Runnable conditionCheck) {
long startTime = System.currentTimeMillis();
long maxWaitMillis = maxWaitSeconds * 1000L;
while (System.currentTimeMillis() - startTime < maxWaitMillis) {
try {
conditionCheck.run();
return;
} catch (Exception e) {
try {
Thread.sleep(1000);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
throw new RuntimeException("Wait interrupted", ie);
}
}
}
throw new RuntimeException("Condition not met within " + maxWaitSeconds + " seconds");
}
}
package com.example.tests.helpers;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import java.util.List;
import java.util.Map;
public class DatabaseUtils {
private static JdbcTemplate jdbcTemplate;
static {
DriverManagerDataSource dataSource = new DriverManagerDataSource();
dataSource.setDriverClassName("org.postgresql.Driver");
dataSource.setUrl("jdbc:postgresql://localhost:5432/testdb");
dataSource.setUsername("testuser");
dataSource.setPassword("testpass");
jdbcTemplate = new JdbcTemplate(dataSource);
}
public static void cleanupUser(String email) {
jdbcTemplate.update("DELETE FROM users WHERE email = ?", email);
}
public static void cleanupOrder(String orderId) {
jdbcTemplate.update("DELETE FROM order_items WHERE order_id = ?", orderId);
jdbcTemplate.update("DELETE FROM orders WHERE id = ?", orderId);
}
public static Map<String, Object> getUserByEmail(String email) {
List<Map<String, Object>> users = jdbcTemplate.queryForList(
"SELECT * FROM users WHERE email = ?", email);
return users.isEmpty() ? null : users.get(0);
}
public static Map<String, Object> getOrderById(String orderId) {
List<Map<String, Object>> orders = jdbcTemplate.queryForList(
"SELECT * FROM orders WHERE id = ?", orderId);
return orders.isEmpty() ? null : orders.get(0);
}
public static void updateProductStock(String productId, int newStock) {
jdbcTemplate.update("UPDATE products SET stock = ? WHERE id = ?", newStock, productId);
}
public static void resetDatabase() {
jdbcTemplate.update("DELETE FROM order_items");
jdbcTemplate.update("DELETE FROM orders");
jdbcTemplate.update("DELETE FROM users");
jdbcTemplate.update("DELETE FROM products");
jdbcTemplate.update("ALTER SEQUENCE users_id_seq RESTART WITH 1");
jdbcTemplate.update("ALTER SEQUENCE orders_id_seq RESTART WITH 1");
}
}

3. Configuration and Hooks

package com.example.tests.utils;
import com.intuit.karate.RuntimeHook;
import com.intuit.karate.core.Scenario;
import com.intuit.karate.core.ScenarioResult;
import com.intuit.karate.core.Feature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class KarateHooks implements RuntimeHook {
private static final Logger logger = LoggerFactory.getLogger(KarateHooks.class);
@Override
public boolean beforeScenario(Scenario scenario) {
logger.info("Starting scenario: {} in feature: {}", 
scenario.getName(), scenario.getFeature().getName());
return true;
}
@Override
public void afterScenario(ScenarioResult result) {
Scenario scenario = result.getScenario();
logger.info("Completed scenario: {} with status: {}", 
scenario.getName(), result.isFailed() ? "FAILED" : "PASSED");
if (result.isFailed()) {
logger.error("Scenario failed with error: {}", result.getError());
}
}
@Override
public boolean beforeFeature(Feature feature) {
logger.info("Starting feature: {}", feature.getName());
return true;
}
@Override
public void afterFeature(Feature feature) {
logger.info("Completed feature: {}", feature.getName());
}
}

Advanced Karate Features

1. GraphQL Testing

# graphql/users-graphql.feature
Feature: GraphQL User API Testing
Background:
* url baseUrl + '/graphql'
* configure headers = { 'Content-Type': 'application/json' }
Scenario: Query user by ID
Given request
"""
{
"query": "query GetUser($userId: ID!) { user(id: $userId) { id firstName lastName email } }",
"variables": { "userId": "1" }
}
"""
When method post
Then status 200
And match response.data.user ==
"""
{
"id": "1",
"firstName": "#string",
"lastName": "#string", 
"email": "#string"
}
"""
Scenario: Create user via GraphQL mutation
Given def userData = { firstName: 'GraphQL', lastName: 'User', email: '[email protected]' }
And request
"""
{
"query": "mutation CreateUser($input: CreateUserInput!) { createUser(input: $input) { user { id firstName lastName email } } }",
"variables": { "input": "#(userData)" }
}
"""
When method post
Then status 200
And match response.data.createUser.user.email == userData.email

2. Performance Testing

# performance/load-test.feature
Feature: User API Load Testing
Background:
* url baseUrl
* configure headers = { 'Content-Type': 'application/json' }
@performance
Scenario: Load test user creation endpoint
* def startTime = function() { return java.lang.System.currentTimeMillis() }
* def createUser = 
"""
function() {
var payload = {
firstName: 'LoadTest',
lastName: 'User' + karate.info.iteration,
email: 'loadtest' + karate.info.iteration + '@example.com',
phone: '+1234567890'
};
karate.set('payload', payload);
}
"""
Given path 'users'
And request payload
When method post
Then status 201
* def endTime = function() { return java.lang.System.currentTimeMillis() }
* def responseTime = endTime - startTime
* print 'Response time: ' + responseTime + 'ms'
@stress
Scenario: Stress test with multiple concurrent users
* configure retry = { count: 3, interval: 1000 }
* call read('classpath:com/example/features/performance/stress-setup.feature')
Given path 'users'
And request { firstName: 'Stress', lastName: 'Test', email: '#(uniqueEmail)' }
When method post
Then status 201

3. Mock Server Testing

# mocks/external-service-mock.feature
Feature: Mock External Service for Testing
Background:
* configure cors = true
* def mockHelper = read('classpath:com/example/features/mocks/mock-helper.js')
Scenario: mock user service
Given path '/users'
When method get
Then status 200
And response { id: 1, name: 'Mock User', email: '[email protected]' }
Scenario: mock user creation
Given path '/users'
And request { name: '#string', email: '#string' }
When method post
Then status 201
And def response = { id: '#(mockHelper.nextId())', name: '#(request.name)', email: '#(request.email)' }
Scenario: mock with dynamic response
Given path '/users', userId
When method get
Then
"""
if (userId == '1') {
karate.set('response', { id: 1, name: 'User One' });
} else if (userId == '2') {
karate.set('response', { id: 2, name: 'User Two' }); 
} else {
karate.set('responseStatus', 404);
karate.set('response', { error: 'User not found' });
}
"""

Configuration Files

1. Karate Configuration

// karate-config.js
function fn() {
var env = karate.env || 'dev';
karate.log('karate.env system property was:', env);
var config = {
env: env,
baseUrl: 'http://localhost:8080/api/v1',
authToken: null,
requestTimeout: 30000,
retryInterval: 1000,
retryCount: 3
};
if (env == 'dev') {
config.baseUrl = 'http://localhost:8080/api/v1';
config.dbUrl = 'jdbc:postgresql://localhost:5432/devdb';
} else if (env == 'qa') {
config.baseUrl = 'https://qa-api.example.com/api/v1';
config.dbUrl = 'jdbc:postgresql://qa-db.example.com:5432/qadb';
} else if (env == 'staging') {
config.baseUrl = 'https://staging-api.example.com/api/v1';
config.dbUrl = 'jdbc:postgresql://staging-db.example.com:5432/stagingdb';
} else if (env == 'prod') {
config.baseUrl = 'https://api.example.com/api/v1';
// No direct DB access in prod
}
// Authentication setup
if (env != 'dev') {
var authResult = karate.callSingle('classpath:com/example/features/common/auth.feature', config);
config.authToken = authResult.authToken;
}
// Configure headers for all requests
karate.configure('headers', {
'Content-Type': 'application/json',
'User-Agent': 'Karate-Tests/1.0.0',
'X-Request-ID': '#(java.util.UUID.randomUUID().toString())'
});
karate.configure('retry', { count: config.retryCount, interval: config.retryInterval });
karate.configure('connectTimeout', config.requestTimeout);
karate.configure('readTimeout', config.requestTimeout);
return config;
}

2. JavaScript Utilities

// common/utils.js
function generateRandomEmail() {
var timestamp = new Date().getTime();
return 'test-' + timestamp + '@example.com';
}
function generateRandomPhone() {
return '+1' + Math.floor(1000000000 + Math.random() * 9000000000);
}
function validateResponseSchema(response, schema) {
var matchResult = karate.match(response, schema);
if (!matchResult.pass) {
karate.fail('Schema validation failed: ' + matchResult.message);
}
}
function waitForCondition(conditionFn, timeoutMs) {
var startTime = new Date().getTime();
while (new Date().getTime() - startTime < timeoutMs) {
if (conditionFn()) {
return true;
}
java.lang.Thread.sleep(1000);
}
return false;
}
function parseJsonSafe(jsonString) {
try {
return JSON.parse(jsonString);
} catch (e) {
return null;
}
}

CI/CD Integration

1. GitHub Actions

# .github/workflows/karate-tests.yml
name: Karate API Tests
on:
push:
branches: [ main, develop ]
pull_request:
branches: [ main ]
jobs:
api-tests:
runs-on: ubuntu-latest
services:
postgres:
image: postgres:13
env:
POSTGRES_PASSWORD: test
POSTGRES_USER: test
POSTGRES_DB: testdb
options: >-
--health-cmd pg_isready
--health-interval 10s
--health-timeout 5s
--health-retries 5
ports:
- 5432:5432
steps:
- uses: actions/checkout@v4
- name: Set up JDK 17
uses: actions/setup-java@v4
with:
java-version: '17'
distribution: 'temurin'
cache: 'maven'
- name: Start Application
run: |
mvn spring-boot:run &
echo $! > app.pid
sleep 30
- name: Run Karate Tests
run: |
mvn test -Dtest=ParallelRunner -Dkarate.env=ci
sleep 10
- name: Stop Application
if: always()
run: |
kill $(cat app.pid) || true
- name: Upload Test Reports
if: always()
uses: actions/upload-artifact@v4
with:
name: karate-reports
path: target/karate-reports/
- name: Publish Test Results
if: always()
uses: dorny/test-reporter@v1
with:
name: Karate Test Results
path: target/karate-reports/*.xml
reporter: java-junit

Best Practices

1. Test Organization

# common/common.feature
Feature: Common Utilities and Setup
Background:
* def JavaHelpers = Java.type('com.example.tests.helpers.JavaHelpers')
* def DatabaseUtils = Java.type('com.example.tests.helpers.DatabaseUtils')
* def generateEmail = function() { return JavaHelpers.generateUniqueEmail() }
* def cleanupUser = function(email) { DatabaseUtils.cleanupUser(email) }
@setup
Scenario: Global setup for test suite
* configure afterScenario =
"""
function() {
var email = __arg.email || __arg.userData && __arg.userData.email;
if (email) {
karate.call('common.feature@cleanup', { email: email });
}
}
"""
@cleanup
Scenario: Cleanup test data
* print 'Cleaning up test data for email:', email
* eval if (email) DatabaseUtils.cleanupUser(email)
@auth
Scenario: Get authentication token
Given url baseUrl
And path 'auth', 'login'
And request { username: '#(username)', password: '#(password)' }
When method post
Then status 200
And def authToken = response.token
And match authToken != null

2. Error Handling and Retry

# common/retry.feature
Feature: Retry and Error Handling
Background:
* configure retry = { count: 3, interval: 2000 }
@retry
Scenario: Retry flaky endpoint
Given path 'flaky-endpoint'
When method get
Then status 200
And match response.status == 'READY'
@errorhandling
Scenario: Handle expected errors gracefully
Given path 'users', 'invalid-id'
When method get
Then status 404
And match response ==
"""
{
"errorCode": "USER_NOT_FOUND",
"message": "#string",
"timestamp": "#notnull"
}
"""
Scenario: Validate error response structure
* def errorSchema =
"""
{
"errorCode": "#string",
"message": "#string", 
"timestamp": "#string",
"details": "##[]"
}
"""
Given path 'invalid-endpoint'
When method get
Then status 404
And match response == errorSchema

Conclusion

Karate DSL provides a comprehensive solution for API testing with:

Readable Syntax - BDD-style tests that are easy to understand
Powerful Assertions - Rich matching capabilities with JSON schema validation
Java Integration - Seamless integration with Java helpers and utilities
Performance Testing - Built-in support for load and performance testing
Mock Servers - Ability to create mocks for external dependencies
CI/CD Ready - Easy integration with modern CI/CD pipelines

By following these patterns and best practices, teams can build maintainable, reliable, and comprehensive API test suites that scale with their applications.

Pyroscope Profiling in Java
Explains how to use Pyroscope for continuous profiling in Java applications, helping developers analyze CPU and memory usage patterns to improve performance and identify bottlenecks.
https://macronepal.com/blog/pyroscope-profiling-in-java/

OpenTelemetry Metrics in Java: Comprehensive Guide
Provides a complete guide to collecting and exporting metrics in Java using OpenTelemetry, including counters, histograms, gauges, and integration with monitoring tools. (MACRO NEPAL)
https://macronepal.com/blog/opentelemetry-metrics-in-java-comprehensive-guide/

OTLP Exporter in Java: Complete Guide for OpenTelemetry
Explains how to configure OTLP exporters in Java to send telemetry data such as traces, metrics, and logs to monitoring systems using HTTP or gRPC protocols. (MACRO NEPAL)
https://macronepal.com/blog/otlp-exporter-in-java-complete-guide-for-opentelemetry/

Thanos Integration in Java: Global View of Metrics
Explains how to integrate Thanos with Java monitoring systems to create a scalable global metrics view across multiple Prometheus instances.

https://macronepal.com/blog/thanos-integration-in-java-global-view-of-metrics

Time Series with InfluxDB in Java: Complete Guide (Version 2)
Explains how to manage time-series data using InfluxDB in Java applications, including storing, querying, and analyzing metrics data.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide-2

Time Series with InfluxDB in Java: Complete Guide
Provides an overview of integrating InfluxDB with Java for time-series data handling, including monitoring applications and managing performance metrics.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide

Implementing Prometheus Remote Write in Java (Version 2)
Explains how to configure Java applications to send metrics data to Prometheus-compatible systems using the remote write feature for scalable monitoring.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide-2

Implementing Prometheus Remote Write in Java: Complete Guide
Provides instructions for sending metrics from Java services to Prometheus servers, enabling centralized monitoring and real-time analytics.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide

Building a TileServer GL in Java: Vector and Raster Tile Server
Explains how to build a TileServer GL in Java for serving vector and raster map tiles, useful for geographic visualization and mapping applications.

https://macronepal.com/blog/building-a-tileserver-gl-in-java-vector-and-raster-tile-server

Indoor Mapping in Java
Explains how to create indoor mapping systems in Java, including navigation inside buildings, spatial data handling, and visualization techniques.