0
# Multi-Logger System
1

2
Create and manage multiple independent logger instances for modular applications, allowing different parts of your application to have separate logging configurations.
3

4
## Capabilities
5

6
### getLogger
7

8
```javascript { .api }
9
/**
10
 * Create or retrieve a named logger instance
11
 * Returns the same instance when called repeatedly with the same name
12
 * @param {string | symbol} name - Logger name (non-empty string or symbol)
13
 * @returns {Logger} Logger instance with independent level settings
14
 * @throws {TypeError} When name is empty string, undefined, or invalid type
15
 */
16
getLogger(name: string | symbol): Logger;
17

18
// Type definitions
19
type LogLevelNumbers = 0 | 1 | 2 | 3 | 4 | 5;
20
type LogLevelNames = 'trace' | 'debug' | 'info' | 'warn' | 'error';
21
type LogLevelDesc = LogLevelNumbers | LogLevelNames | 'silent' | keyof LogLevel;
22

23
// Logger interface (individual loggers)
24
interface Logger {
25
  // All logging methods
26
  trace(...msg: any[]): void;
27
  debug(...msg: any[]): void;
28
  log(...msg: any[]): void;
29
  info(...msg: any[]): void;
30
  warn(...msg: any[]): void;
31
  error(...msg: any[]): void;
32
  
33
  // Level control methods  
34
  setLevel(level: LogLevelDesc, persist?: boolean): void;
35
  getLevel(): LogLevelNumbers;
36
  setDefaultLevel(level: LogLevelDesc): void;
37
  resetLevel(): void;
38
  enableAll(persist?: boolean): void;
39
  disableAll(persist?: boolean): void;
40
  
41
  // Plugin system
42
  methodFactory: MethodFactory;
43
  rebuild(): void;
44
  
45
  // Properties
46
  readonly levels: LogLevel;
47
  readonly name: string | symbol;
48
}
49
```
50

51
**Usage Examples:**
52

53
```javascript
54
import log from 'loglevel';
55

56
// Create named loggers for different modules
57
const dbLogger = log.getLogger('database');
58
const apiLogger = log.getLogger('api');
59
const uiLogger = log.getLogger('ui');
60

61
// Each logger has independent level settings
62
dbLogger.setLevel('debug');
63
apiLogger.setLevel('info');
64
uiLogger.setLevel('warn');
65

66
// Use loggers independently
67
dbLogger.debug('Connection established'); // Shows (debug level)
68
apiLogger.debug('Request details');       // Hidden (info level)
69
apiLogger.info('API call successful');    // Shows (info level)
70
uiLogger.info('Button clicked');          // Hidden (warn level)
71
uiLogger.warn('Validation failed');       // Shows (warn level)
72

73
// Same name returns same instance
74
const dbLogger2 = log.getLogger('database');
75
console.log(dbLogger === dbLogger2); // true
76

77
// Symbol names for private loggers
78
const privateLogger = log.getLogger(Symbol('internal'));
79
```
80

81
### getLoggers
82

83
```javascript { .api }
84
/**
85
 * Get dictionary of all created loggers
86
 * Returns object with logger names as keys and instances as values
87
 * @returns {Object} Object mapping logger names to Logger instances
88
 */
89
getLoggers(): { [name: string]: Logger };
90
```
91

92
**Usage Examples:**
93

94
```javascript
95
import log from 'loglevel';
96

97
// Create some loggers
98
const moduleA = log.getLogger('moduleA');
99
const moduleB = log.getLogger('moduleB');
100

101
// Get all loggers
102
const allLoggers = log.getLoggers();
103
console.log(Object.keys(allLoggers)); // ['moduleA', 'moduleB']
104

105
// Iterate over all loggers
106
Object.entries(allLoggers).forEach(([name, logger]) => {
107
  console.log(`Logger ${name} is at level ${logger.getLevel()}`);
108
});
109

110
// Bulk operations on all loggers  
111
function setAllLoggersLevel(level) {
112
  Object.values(log.getLoggers()).forEach(logger => {
113
    logger.setLevel(level);
114
  });
115
}
116

117
setAllLoggersLevel('error'); // Set all named loggers to error level
118
```
119

120
### noConflict
121

122
```javascript { .api }
123
/**
124
 * Release global 'log' variable and return loglevel instance
125
 * Resolves naming conflicts with other libraries
126
 * @returns {RootLogger} The loglevel root logger instance
127
 */
128
noConflict(): RootLogger;
129
```
130

131
**Usage Examples:**
132

133
```javascript
134
// Browser environment with conflicting 'log' global
135
<script src="other-library-with-log.js"></script>
136
<script src="loglevel.min.js"></script>
137
<script>
138
  // Resolve conflict and get loglevel instance
139
  const loglevel = log.noConflict();
140
  
141
  // Now 'log' refers to the other library
142
  // Use 'loglevel' for loglevel functionality
143
  loglevel.setLevel('debug');
144
  loglevel.info('Using loglevel via noConflict');
145
</script>
146
```
147

148
## Logger Hierarchies and Inheritance
149

150
Named loggers inherit their initial level from the root logger but maintain independence:
151

152
```javascript
153
import log from 'loglevel';
154

155
// Set root logger level
156
log.setLevel('warn');
157

158
// New loggers start with inherited level
159
const childLogger = log.getLogger('child');
160
console.log(childLogger.getLevel()); // 3 (warn level)
161

162
// Child can have independent level
163
childLogger.setLevel('debug');
164
console.log(log.getLevel());       // 3 (warn - unchanged)
165
console.log(childLogger.getLevel()); // 1 (debug - independent)
166

167
// Changing root level doesn't affect existing children
168
log.setLevel('error');
169
console.log(childLogger.getLevel()); // 1 (debug - still independent)
170
```
171

172
## Modular Application Example
173

174
```javascript
175
import log from 'loglevel';
176

177
// Application modules with separate logging
178
class DatabaseManager {
179
  constructor() {
180
    this.logger = log.getLogger('database');
181
    this.logger.setLevel('debug'); // Detailed DB logging
182
  }
183
  
184
  connect() {
185
    this.logger.debug('Attempting connection...');
186
    this.logger.info('Connected to database');
187
  }
188
  
189
  query(sql) {
190
    this.logger.debug('Executing query:', sql);
191
  }
192
}
193

194
class APIService {
195
  constructor() {
196
    this.logger = log.getLogger('api');
197
    this.logger.setLevel('info'); // Moderate API logging
198
  }
199
  
200
  request(url) {
201
    this.logger.info('API request:', url);
202
    this.logger.debug('This debug message is hidden');
203
  }
204
}
205

206
class UserInterface {
207
  constructor() {
208
    this.logger = log.getLogger('ui');
209
    this.logger.setLevel('warn'); // Minimal UI logging
210
  }
211
  
212
  render() {
213
    this.logger.info('This info message is hidden');
214
    this.logger.warn('Rendering warning');
215
  }
216
}
217

218
// Usage
219
const db = new DatabaseManager();
220
const api = new APIService();  
221
const ui = new UserInterface();
222

223
db.connect();     // Shows debug and info messages
224
api.request('/');  // Shows info message only
225
ui.render();      // Shows warn message only
226
```
227

228
## Logger Persistence
229

230
Named loggers have independent persistence with namespaced storage keys:
231

232
```javascript
233
import log from 'loglevel';
234

235
// Root logger uses "loglevel" storage key
236
log.setLevel('warn');
237

238
// Named loggers use "loglevel:name" format
239
const moduleLogger = log.getLogger('mymodule');
240
moduleLogger.setLevel('debug'); // Stored as "loglevel:mymodule"
241

242
// Levels persist independently across sessions
243
// Root logger: localStorage["loglevel"] = "WARN" 
244
// Named logger: localStorage["loglevel:mymodule"] = "DEBUG"
245

246
// Symbol-named loggers don't persist (no string key)
247
const symbolLogger = log.getLogger(Symbol('temp'));
248
symbolLogger.setLevel('trace'); // Not persisted
249
```