WMS/WES Service Decoupling Plan

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
wave-planning-service/
├── src/main/java/com/paklog/wms/wave/
│   ├── domain/
│   │   ├── aggregate/
│   │   │   ├── Wave.java
│   │   │   ├── WavePlan.java
│   │   │   └── WaveStrategy.java
│   │   ├── entity/
│   │   │   ├── WaveMetrics.java
│   │   │   └── CarrierCutoff.java
│   │   ├── valueobject/
│   │   │   ├── WaveId.java
│   │   │   ├── WaveStatus.java
│   │   │   └── Priority.java
│   │   ├── service/
│   │   │   ├── WavePlanningService.java
│   │   │   ├── CapacityCalculationService.java
│   │   │   └── WorkloadForecastingService.java
│   │   └── repository/
│   │       └── WaveRepository.java
│   │
│   ├── application/
│   │   ├── command/
│   │   │   ├── CreateWaveCommand.java
│   │   │   ├── ReleaseWaveCommand.java
│   │   │   └── CancelWaveCommand.java
│   │   ├── query/
│   │   │   ├── GetWaveStatusQuery.java
│   │   │   └── ListPendingWavesQuery.java
│   │   └── saga/
│   │       └── WaveReleaseSaga.java
│   │
│   ├── infrastructure/
│   │   ├── persistence/
│   │   │   └── MongoWaveRepository.java
│   │   ├── messaging/
│   │   │   ├── KafkaEventPublisher.java
│   │   │   └── OrderEventListener.java
│   │   └── rest/
│   │       └── WaveController.java
│   │
│   └── integration/
│       ├── inventory/
│       │   └── InventoryServiceClient.java
│       └── order/
│           └── OrderServiceClient.java
│
├── src/main/resources/
│   ├── application.yml
│   └── db/migration/
│       └── V1__create_wave_tables.sql
│
└── src/test/java/
    ├── unit/
    ├── integration/
    └── contract/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// Core Wave Aggregate
@AggregateRoot
@Document(collection = "waves")
public class Wave {
    @Id
    private String waveId;
    private WaveStatus status;
    private List<String> orderIds;
    private WavePriority priority;
    private WaveStrategy strategy;
    private LocalDateTime plannedReleaseTime;
    private LocalDateTime actualReleaseTime;
    private String assignedWarehouseId;
    private String assignedZone;
    private WaveMetrics metrics;
    private int version; // Optimistic locking

    // State transitions
    public void plan(List<String> orderIds, WaveStrategy strategy) {
        // Business logic for wave planning
        validateOrders(orderIds);
        this.orderIds = orderIds;
        this.strategy = strategy;
        this.status = WaveStatus.PLANNED;
        registerEvent(new WavePlannedEvent(this));
    }

    public void release() {
        ensureStatus(WaveStatus.PLANNED);
        ensureInventoryAllocated();
        this.status = WaveStatus.RELEASED;
        this.actualReleaseTime = LocalDateTime.now();
        registerEvent(new WaveReleasedEvent(this));
    }

    public void complete() {
        ensureStatus(WaveStatus.IN_PROGRESS);
        this.status = WaveStatus.COMPLETED;
        registerEvent(new WaveCompletedEvent(this));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Events Published
@CloudEvent
public class WavePlannedEvent {
    private String waveId;
    private List<String> orderIds;
    private String warehouseId;
    private String strategy;
    private LocalDateTime plannedReleaseTime;
}

@CloudEvent
public class WaveReleasedEvent {
    private String waveId;
    private List<String> orderIds;
    private String warehouseId;
    private String assignedZone;
    private Priority priority;
}

// Events Consumed
- FulfillmentOrderValidatedEvent (from Order Management)
- InventoryAllocatedEvent (from Inventory)
- PickingCompletedEvent (from Pick Execution - future)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// In existing service
@EventListener
public void onWaveCreated(WaveCreatedEvent event) {
    // Existing logic continues
    processWaveLocally(event);

    // Also forward to new service (shadow mode)
    wavePlanningServiceClient.createWave(event);

    // Compare results
    metricsCollector.compareWaveResults(
        localResult,
        remoteResult
    );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Feature flag based routing
@Service
public class WaveServiceRouter {
    @Value("${feature.wave-planning.percentage:0}")
    private int routingPercentage;

    public WaveResponse processWave(WaveRequest request) {
        if (shouldRouteToNew(request.getCustomerId())) {
            return wavePlanningService.process(request);
        } else {
            return legacyWaveService.process(request);
        }
    }

    private boolean shouldRouteToNew(String customerId) {
        return customerId.hashCode() % 100 < routingPercentage;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
task-execution-service/
├── src/main/java/com/paklog/wes/task/
│   ├── domain/
│   │   ├── aggregate/
│   │   │   ├── WorkTask.java
│   │   │   └── TaskAssignment.java
│   │   ├── entity/
│   │   │   ├── TaskQueue.java
│   │   │   └── Associate.java
│   │   ├── valueobject/
│   │   │   ├── TaskType.java
│   │   │   ├── TaskStatus.java
│   │   │   └── Priority.java
│   │   ├── service/
│   │   │   ├── TaskOrchestrationService.java
│   │   │   ├── TaskAssignmentService.java
│   │   │   └── TaskOptimizationService.java
│   │   └── factory/
│   │       ├── PickTaskFactory.java
│   │       ├── PackTaskFactory.java
│   │       └── ReplenishTaskFactory.java
│   │
│   ├── application/
│   │   ├── command/
│   │   │   ├── CreateTaskCommand.java
│   │   │   ├── AssignTaskCommand.java
│   │   │   └── CompleteTaskCommand.java
│   │   ├── query/
│   │   │   ├── GetAssignedTasksQuery.java
│   │   │   └── GetTaskQueueQuery.java
│   │   └── handler/
│   │       ├── WaveReleasedHandler.java
│   │       └── InventoryEventHandler.java
│   │
│   └── infrastructure/
│       ├── api/
│       │   ├── TaskController.java
│       │   └── MobileTaskController.java
│       └── messaging/
│           └── TaskEventPublisher.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
@AggregateRoot
@Document(collection = "work_tasks")
public class WorkTask {
    @Id
    private String taskId;
    private TaskType type; // PICK, PACK, PUTAWAY, COUNT, REPLENISH
    private TaskStatus status;
    private Priority priority;
    private String assignedTo;
    private LocalDateTime createdAt;
    private LocalDateTime assignedAt;
    private LocalDateTime startedAt;
    private LocalDateTime completedAt;
    private String referenceId; // Wave, Order, etc.
    private Map<String, Object> taskContext; // Type-specific data
    private Duration estimatedDuration;
    private Location taskLocation;

    // Polymorphic task creation
    public static WorkTask createPickTask(
        String waveId,
        List<PickInstruction> instructions
    ) {
        WorkTask task = new WorkTask();
        task.type = TaskType.PICK;
        task.referenceId = waveId;
        task.taskContext = Map.of("instructions", instructions);
        task.priority = calculatePickPriority(instructions);
        return task;
    }

    // Task lifecycle
    public void assign(String associateId) {
        ensureStatus(TaskStatus.PENDING);
        validateAssociate(associateId);
        this.assignedTo = associateId;
        this.assignedAt = LocalDateTime.now();
        this.status = TaskStatus.ASSIGNED;
        registerEvent(new TaskAssignedEvent(this));
    }

    public void start() {
        ensureStatus(TaskStatus.ASSIGNED);
        this.startedAt = LocalDateTime.now();
        this.status = TaskStatus.IN_PROGRESS;
        registerEvent(new TaskStartedEvent(this));
    }

    public void complete(Map<String, Object> results) {
        ensureStatus(TaskStatus.IN_PROGRESS);
        this.completedAt = LocalDateTime.now();
        this.status = TaskStatus.COMPLETED;
        this.taskContext.putAll(results);
        registerEvent(new TaskCompletedEvent(this));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
@Service
public class TaskAssignmentService {

    public TaskAssignment assignTask(WorkTask task) {
        // Get available associates
        List<Associate> availableAssociates = associateRepository
            .findByStatusAndSkills(
                AssociateStatus.AVAILABLE,
                task.getRequiredSkills()
            );

        // Score each associate
        List<AssociateScore> scores = availableAssociates.stream()
            .map(associate -> scoreAssociate(associate, task))
            .sorted(Comparator.reverseOrder())
            .collect(Collectors.toList());

        // Assign to best match
        Associate selected = scores.get(0).getAssociate();
        task.assign(selected.getId());

        // Update associate status
        selected.assignTask(task.getTaskId());

        // Send notification
        notificationService.notifyAssociate(selected, task);

        return new TaskAssignment(task, selected);
    }

    private AssociateScore scoreAssociate(
        Associate associate,
        WorkTask task
    ) {
        double score = 0;

        // Distance to task location
        score += scoreDistance(
            associate.getCurrentLocation(),
            task.getTaskLocation()
        );

        // Skill match
        score += scoreSkillMatch(
            associate.getSkills(),
            task.getRequiredSkills()
        );

        // Current workload
        score += scoreWorkload(
            associate.getCurrentTasks()
        );

        // Historical performance
        score += scorePerformance(
            associate.getProductivityMetrics(),
            task.getType()
        );

        return new AssociateScore(associate, score);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Component
public class WaveEventHandler {

    @EventHandler
    public void handle(WaveReleasedEvent event) {
        // Generate pick tasks from wave
        List<WorkTask> pickTasks = pickTaskFactory
            .createTasksFromWave(event);

        // Save tasks
        pickTasks.forEach(taskRepository::save);

        // Assign tasks
        pickTasks.forEach(taskAssignmentService::assignTask);

        // Publish task creation events
        pickTasks.forEach(task ->
            eventPublisher.publish(new TaskCreatedEvent(task))
        );
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
@AggregateRoot
@Document(collection = "location_masters")
public class LocationMaster {
    @Id
    private String locationId;
    private String warehouseId;
    private String zone;
    private String aisle;
    private String bay;
    private String bin;
    private LocationType type; // PICK, RESERVE, STAGE, DOCK
    private Dimensions dimensions;
    private WeightCapacity weightCapacity;
    private VolumeCapacity volumeCapacity;
    private List<String> restrictions; // HAZMAT, FROZEN, etc.
    private SlottingClass slottingClass; // A, B, C
    private boolean active;

    // Configuration methods
    public void configureCapacity(Capacity newCapacity) {
        validateCapacity(newCapacity);
        this.weightCapacity = newCapacity.getWeight();
        this.volumeCapacity = newCapacity.getVolume();
        registerEvent(new LocationCapacityConfiguredEvent(this));
    }

    public void assignSlottingClass(SlottingClass newClass) {
        this.slottingClass = newClass;
        registerEvent(new LocationSlottingChangedEvent(this));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@AggregateRoot
@Document(collection = "location_states")
public class LocationState {
    @Id
    private String locationId; // Links to LocationMaster
    private OccupancyStatus occupancyStatus;
    private int currentItemCount;
    private double currentWeight;
    private double currentVolume;
    private List<String> licensePlates;
    private LocationStatus status; // AVAILABLE, OCCUPIED, BLOCKED
    private String blockedReason;
    private LocalDateTime lastMovement;
    private LocalDateTime lastCycleCount;

    // State management
    public void recordMovement(Movement movement) {
        updateOccupancy(movement);
        this.lastMovement = LocalDateTime.now();
        registerEvent(new LocationMovementEvent(this, movement));
    }

    public void blockLocation(String reason) {
        this.status = LocationStatus.BLOCKED;
        this.blockedReason = reason;
        registerEvent(new LocationBlockedEvent(this));
    }
}

@AggregateRoot
@Document(collection = "license_plates")
public class LicensePlate {
    @Id
    private String licensePlateId;
    private LicensePlateType type; // PALLET, CASE, CARTON, TOTE
    private List<LPItem> contents;
    private String currentLocationId;
    private LPStatus status;
    private String parentLicensePlateId; // For nested LPs
    private LocalDateTime createdAt;
    private LocalDateTime lastMovedAt;

    public void moveTo(String newLocationId) {
        validateLocation(newLocationId);
        String oldLocation = this.currentLocationId;
        this.currentLocationId = newLocationId;
        this.lastMovedAt = LocalDateTime.now();
        registerEvent(new LicensePlateMoved(this, oldLocation, newLocationId));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
// Bi-directional synchronization
Location Master Service (WMS) ←→ Physical Tracking Service (WES)

// Events from Location Master → Physical Tracking
- LocationCreatedEvent
- LocationCapacityChangedEvent
- LocationDeactivatedEvent

// Events from Physical Tracking → Location Master
- LocationCapacityExceededEvent
- LocationBlockedEvent
- AbnormalInventoryDetectedEvent

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
@AggregateRoot
@Document(collection = "pick_sessions")
public class PickSession {
    @Id
    private String sessionId;
    private String pickListId;
    private String pickerId;
    private List<PickInstruction> instructions;
    private PickStrategy strategy; // DISCRETE, BATCH, ZONE, CLUSTER
    private PickPath optimizedPath;
    private SessionStatus status;
    private List<PickConfirmation> confirmations;
    private LocalDateTime startedAt;
    private LocalDateTime completedAt;
    private PickMetrics metrics;

    public void optimizePath(LocationGraph graph) {
        this.optimizedPath = pathOptimizer.optimize(
            instructions,
            graph,
            strategy
        );
        reorderInstructions();
    }

    public void confirmPick(
        String instructionId,
        int quantity,
        String barcode
    ) {
        PickInstruction instruction = findInstruction(instructionId);
        validateBarcode(barcode, instruction.getSku());

        if (quantity < instruction.getQuantity()) {
            handleShortPick(instruction, quantity);
        }

        confirmations.add(new PickConfirmation(
            instructionId,
            quantity,
            LocalDateTime.now()
        ));

        if (allInstructionsComplete()) {
            complete();
        }
    }
}

@Entity
public class PutWallSlot {
    private String slotId;
    private int slotNumber;
    private String assignedOrderId;
    private SlotStatus status;
    private List<SlotItem> items;
    private int expectedItemCount;
    private int currentItemCount;

    public void addItem(String sku, int quantity) {
        validateSku(sku);
        items.add(new SlotItem(sku, quantity));
        currentItemCount += quantity;

        if (currentItemCount >= expectedItemCount) {
            status = SlotStatus.COMPLETE;
            registerEvent(new PutWallOrderCompleteEvent(
                assignedOrderId,
                slotId
            ));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
@Service
public class PickPathOptimizer {

    public PickPath optimize(
        List<PickInstruction> instructions,
        LocationGraph warehouse,
        PickStrategy strategy
    ) {
        return switch (strategy) {
            case DISCRETE -> optimizeDiscrete(instructions, warehouse);
            case BATCH -> optimizeBatch(instructions, warehouse);
            case ZONE -> optimizeZone(instructions, warehouse);
            case CLUSTER -> optimizeCluster(instructions, warehouse);
        };
    }

    private PickPath optimizeBatch(
        List<PickInstruction> instructions,
        LocationGraph warehouse
    ) {
        // Group by proximity
        List<LocationCluster> clusters = clusterLocations(
            instructions.stream()
                .map(PickInstruction::getLocation)
                .collect(Collectors.toList())
        );

        // Solve TSP for each cluster
        List<Location> optimizedSequence = new ArrayList<>();
        for (LocationCluster cluster : clusters) {
            List<Location> clusterPath = solveTSP(
                cluster.getLocations(),
                warehouse
            );
            optimizedSequence.addAll(clusterPath);
        }

        return new PickPath(
            optimizedSequence,
            calculateDistance(optimizedSequence),
            estimateTime(optimizedSequence)
        );
    }

    private List<Location> solveTSP(
        List<Location> locations,
        LocationGraph warehouse
    ) {
        // Nearest neighbor heuristic with 2-opt improvement
        List<Location> tour = nearestNeighbor(locations, warehouse);
        return twoOptImprovement(tour, warehouse);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@RestController
@RequestMapping("/api/v1/mobile/picking")
public class MobilePickingController {

    @GetMapping("/next-task")
    public PickTaskResponse getNextTask(
        @AuthenticationPrincipal Associate picker
    ) {
        PickSession activeSession = sessionRepository
            .findActiveByPicker(picker.getId())
            .orElseGet(() -> assignNewSession(picker));

        PickInstruction nextInstruction = activeSession
            .getNextInstruction();

        return PickTaskResponse.builder()
            .instruction(nextInstruction)
            .navigation(generateNavigation(
                picker.getCurrentLocation(),
                nextInstruction.getLocation()
            ))
            .build();
    }

    @PostMapping("/confirm")
    public ConfirmationResponse confirmPick(
        @RequestBody PickConfirmationRequest request,
        @AuthenticationPrincipal Associate picker
    ) {
        PickSession session = sessionRepository
            .findActiveByPicker(picker.getId())
            .orElseThrow();

        session.confirmPick(
            request.getInstructionId(),
            request.getQuantity(),
            request.getBarcode()
        );

        sessionRepository.save(session);

        return ConfirmationResponse.builder()
            .success(true)
            .nextInstruction(session.getNextInstruction())
            .build();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
@AggregateRoot
public class PackingSession {
    private String sessionId;
    private String orderId;
    private String packerId;
    private String stationId;
    private List<ItemToScan> itemsToScan;
    private String selectedCarton;
    private Weight actualWeight;
    private PackingStatus status;
    private QualityCheck qualityCheck;

    public void scanItem(String barcode) {
        ItemToScan item = findByBarcode(barcode);
        item.markScanned();

        if (requiresQualityCheck(item)) {
            initiateQualityCheck(item);
        }

        if (allItemsScanned()) {
            readyForCartonSelection();
        }
    }

    public void performQualityCheck(QualityCheckResult result) {
        this.qualityCheck = new QualityCheck(result);

        if (!result.passed()) {
            handleQualityFailure(result);
        }
    }

    public void weighAndClose(Weight weight) {
        validateWeight(weight);
        this.actualWeight = weight;
        this.status = PackingStatus.READY_TO_SHIP;
        registerEvent(new PackingCompletedEvent(this));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Service
public class MovementTrackingService {

    public void trackMovement(MovementRequest request) {
        // Validate movement
        LocationState fromLocation = locationRepository
            .findById(request.getFromLocationId());
        LocationState toLocation = locationRepository
            .findById(request.getToLocationId());

        // Update license plate
        LicensePlate lp = licensePlateRepository
            .findById(request.getLicensePlateId());
        lp.moveTo(request.getToLocationId());

        // Update location states
        fromLocation.removeLP(lp.getId());
        toLocation.addLP(lp.getId());

        // Create movement record
        Movement movement = new Movement(
            request,
            LocalDateTime.now()
        );
        movementRepository.save(movement);

        // Publish event
        eventPublisher.publish(new PhysicalMovementEvent(movement));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
paklog-events/
├── src/main/java/com/paklog/events/
│   ├── wms/
│   │   ├── WaveReleasedEvent.java
│   │   ├── InventoryAllocatedEvent.java
│   │   └── LocationConfiguredEvent.java
│   ├── wes/
│   │   ├── TaskCompletedEvent.java
│   │   ├── PickingCompletedEvent.java
│   │   └── MovementCompletedEvent.java
│   └── common/
│       ├── CloudEventBuilder.java
│       └── EventMetadata.java

1
2
3
4
5
6
7
8
9
10
11
paklog-integration/
├── src/main/java/com/paklog/integration/
│   ├── saga/
│   │   ├── SagaOrchestrator.java
│   │   └── CompensationManager.java
│   ├── outbox/
│   │   ├── OutboxProcessor.java
│   │   └── TransactionalOutbox.java
│   └── reconciliation/
│       ├── ReconciliationService.java
│       └── VarianceDetector.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@SpringBootTest
@AutoConfigureMockMvc
class WaveReleaseContractTest {

    @Test
    void whenWaveReleased_thenTasksGenerated() {
        // Given: Wave Planning Service publishes event
        WaveReleasedEvent event = createWaveReleasedEvent();

        // When: Event is published
        kafkaTemplate.send("wms.wave.events", event);

        // Then: Task Execution Service creates tasks
        await().atMost(5, SECONDS).until(() -> {
            List<WorkTask> tasks = taskRepository
                .findByReferenceId(event.getWaveId());
            return tasks.size() == event.getOrderIds().size();
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
@E2ETest
class FullFulfillmentFlowTest {

    @Test
    void completeOrderFulfillmentFlow() {
        // 1. Create order (WMS)
        Order order = orderService.createOrder(orderRequest);

        // 2. Plan wave (WMS)
        Wave wave = waveService.planWave(Arrays.asList(order));

        // 3. Release wave (WMS → WES)
        waveService.release(wave);

        // 4. Generate tasks (WES)
        await().until(() -> taskService.hasTasks(wave));

        // 5. Execute picking (WES)
        PickSession session = pickService.startSession(wave);
        pickService.complete(session);

        // 6. Pack order (WES)
        PackingSession packing = packService.pack(order);

        // 7. Verify completion
        assertThat(order.getStatus()).isEqualTo(PACKED);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
@Component
public class TracingConfiguration {

    @Bean
    public Tracer tracer() {
        return OpenTelemetry.builder()
            .addSpanProcessor(JaegerSpanExporter.builder()
                .setEndpoint("http://jaeger:14250")
                .build())
            .build()
            .getTracer("paklog");
    }
}