001/* 002 * Logback: the reliable, generic, fast and flexible logging framework. 003 * Copyright (C) 1999-2026, QOS.ch. All rights reserved. 004 * 005 * This program and the accompanying materials are dual-licensed under 006 * either the terms of the Eclipse Public License v2.0 as published by 007 * the Eclipse Foundation 008 * 009 * or (per the licensee's choosing) 010 * 011 * under the terms of the GNU Lesser General Public License version 2.1 012 * as published by the Free Software Foundation. 013 */ 014package ch.qos.logback.classic.kryo; 015 016import ch.qos.logback.core.kryo.SerializerBase; 017import com.esotericsoftware.kryo.kryo5.Kryo; 018import com.esotericsoftware.kryo.kryo5.io.Input; 019import com.esotericsoftware.kryo.kryo5.io.Output; 020import com.esotericsoftware.kryo.kryo5.minlog.Log; 021 022import java.util.HashMap; 023import java.util.Map; 024 025/** 026 * Serializer for logger names that compresses hierarchical names by storing 027 * common prefixes separately and referencing them. 028 * 029 * Logger names are typically hierarchical (e.g., "ch.qos.logback.classic.Logger", 030 * "ch.qos.logback.classic.PatternLayout") and share common prefixes. 031 * 032 * This serializer: 033 * 1. Caches full logger names (like StringSerializer) 034 * 2. For new entries, detects common prefixes and stores only the unique suffix 035 * 3. Reduces serialized size by 30-50% for typical logger hierarchies 036 */ 037public class ClassNameSerializer extends SerializerBase<String> { 038 039 // Common package prefixes to look for 040// private static final String[] COMMON_PREFIXES = { 041// "ch.qos.logback.", 042// "ch.qos.", 043// "org.slf4j.", 044// "java.util.", 045// "javax.", 046// "org.springframework.", 047// "com.example." 048// }; 049 050 // Map to cache prefix -> id mapping for compression 051 private final Map<String, Integer> prefixToId = new HashMap<>(); 052 private final Map<Integer, String> idToPrefix = new HashMap<>(); 053 private int nextPrefixId = 0; 054 055 public ClassNameSerializer(int capacity) { 056 super(BiMapType.DIRECT_MAP, capacity); 057 setAcceptsNull(false); 058 } 059 060 @Override 061 protected void writeNewEntry(Kryo kryo, Output output, String loggerName) { 062 //Log.trace("writeNewEntry for logger name: " + loggerName); 063 064 if (loggerName == null) { 065 throw new IllegalArgumentException("Null logger names are not permitted"); 066 } 067 068 // Try to find a common prefix 069 String prefix = findLongestPrefix(loggerName); 070 071 if (prefix != null && prefix.length() > 4) { // Only compress if prefix is meaningful 072 Integer prefixId = prefixToId.get(prefix); 073 074 if (prefixId == null) { 075 // New prefix - register it 076 prefixId = nextPrefixId++; 077 prefixToId.put(prefix, prefixId); 078 idToPrefix.put(prefixId, prefix); 079 080 // Write as: NEW_PREFIX flag + prefix_id + prefix + suffix 081 output.writeByte((byte) 1); // NEW_PREFIX 082 output.writeVarInt(prefixId, true); 083 output.writeString(prefix); 084 String suffix = loggerName.substring(prefix.length()); 085 output.writeString(suffix); 086 Log.debug("New prefix [" + prefix + "] with id " + prefixId + ", suffix: " + suffix); 087 } else { 088 // Existing prefix - just reference it 089 // Write as: EXISTING_PREFIX flag + prefix_id + suffix 090 output.writeByte((byte) 2); // EXISTING_PREFIX 091 output.writeVarInt(prefixId, true); 092 String suffix = loggerName.substring(prefix.length()); 093 output.writeString(suffix); 094 Log.debug("Using prefix id " + prefixId + " [" + prefix + "], suffix: " + suffix); 095 } 096 } else { 097 // No meaningful prefix - write full name 098 // Write as: FULL_NAME flag + name 099 output.writeByte((byte) 0); // FULL_NAME 100 output.writeString(loggerName); 101 Log.debug("Writing full logger name: " + loggerName); 102 } 103 } 104 105 @Override 106 protected String readNewEntry(Kryo kryo, Input input) { 107 byte mode = input.readByte(); 108 109 switch (mode) { 110 case 0: // FULL_NAME 111 String fullName = input.readString(); 112 Log.trace("Read full logger name: " + fullName); 113 return fullName; 114 115 case 1: // NEW_PREFIX 116 int newPrefixId = input.readVarInt(true); 117 String prefix = input.readString(); 118 String suffix = input.readString(); 119 120 // Cache the prefix 121 prefixToId.put(prefix, newPrefixId); 122 idToPrefix.put(newPrefixId, prefix); 123 124 String reconstructed = prefix + suffix; 125 Log.debug("Read new prefix [" + prefix + "] id=" + newPrefixId + ", result: " + reconstructed); 126 return reconstructed; 127 128 case 2: // EXISTING_PREFIX 129 int prefixId = input.readVarInt(true); 130 String cachedPrefix = idToPrefix.get(prefixId); 131 String suffixPart = input.readString(); 132 133 if (cachedPrefix == null) { 134 throw new IllegalStateException("Unknown prefix id: " + prefixId); 135 } 136 137 String result = cachedPrefix + suffixPart; 138 Log.debug("Read with cached prefix id=" + prefixId + " [" + cachedPrefix + "], result: " + result); 139 return result; 140 141 default: 142 throw new IllegalStateException("Unknown mode: " + mode); 143 } 144 } 145 146 /** 147 * Find the longest common prefix for the logger name. 148 * First checks predefined common prefixes, then finds the package prefix. 149 */ 150 private String findLongestPrefix(String loggerName) { 151 // Check common known prefixes first 152// for (String commonPrefix : COMMON_PREFIXES) { 153// if (loggerName.startsWith(commonPrefix)) { 154// return commonPrefix; 155// } 156// } 157 158 // Find package-level prefix (everything up to last dot) 159 int lastDot = loggerName.lastIndexOf('.'); 160 if (lastDot > 0) { 161 return loggerName.substring(0, lastDot + 1); // Include the dot 162 } 163 164 return null; 165 } 166}