@logtape/adaptor-pino 1.0.0-dev.258 → 1.0.0-dev.262
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +54 -2
- package/deno.json +1 -1
- package/dist/_virtual/rolldown_runtime.cjs +30 -0
- package/dist/mod.cjs +67 -1
- package/dist/mod.d.cts +52 -1
- package/dist/mod.d.cts.map +1 -1
- package/dist/mod.d.ts +53 -2
- package/dist/mod.d.ts.map +1 -1
- package/dist/mod.js +66 -1
- package/dist/mod.js.map +1 -1
- package/mod.ts +73 -1
- package/package.json +2 -2
package/README.md
CHANGED
|
@@ -33,14 +33,66 @@ bun add @logtape/adaptor-pino # for Bun
|
|
|
33
33
|
Usage
|
|
34
34
|
-----
|
|
35
35
|
|
|
36
|
-
|
|
36
|
+
### Using the install() function
|
|
37
|
+
|
|
38
|
+
The simplest way to integrate LogTape with Pino is to use the `install()` function:
|
|
39
|
+
|
|
40
|
+
~~~~ typescript
|
|
41
|
+
import pino from "pino";
|
|
42
|
+
import { install } from "@logtape/adaptor-pino";
|
|
43
|
+
|
|
44
|
+
// With a custom Pino logger
|
|
45
|
+
const pinoLogger = pino({
|
|
46
|
+
level: "info",
|
|
47
|
+
transport: {
|
|
48
|
+
target: "pino-pretty",
|
|
49
|
+
options: {
|
|
50
|
+
colorize: true
|
|
51
|
+
}
|
|
52
|
+
}
|
|
53
|
+
});
|
|
54
|
+
|
|
55
|
+
install(pinoLogger);
|
|
56
|
+
|
|
57
|
+
// That's it! All LogTape logs will now be routed to your Pino logger
|
|
58
|
+
import { getLogger } from "@logtape/logtape";
|
|
59
|
+
const logger = getLogger("my-app");
|
|
60
|
+
logger.info("This will be logged through Pino");
|
|
61
|
+
~~~~
|
|
62
|
+
|
|
63
|
+
You can also pass configuration options:
|
|
64
|
+
|
|
65
|
+
~~~~ typescript
|
|
66
|
+
import { install } from "@logtape/adaptor-pino";
|
|
67
|
+
|
|
68
|
+
// With custom options
|
|
69
|
+
install(pinoLogger, {
|
|
70
|
+
category: {
|
|
71
|
+
position: "start",
|
|
72
|
+
decorator: "[]",
|
|
73
|
+
separator: "."
|
|
74
|
+
}
|
|
75
|
+
});
|
|
76
|
+
~~~~
|
|
77
|
+
|
|
78
|
+
### Manual configuration
|
|
79
|
+
|
|
80
|
+
For full control over the Pino integration, configure LogTape manually:
|
|
37
81
|
|
|
38
82
|
~~~~ typescript
|
|
39
83
|
import { configure } from "@logtape/logtape";
|
|
40
84
|
import { getPinoSink } from "@logtape/adaptor-pino";
|
|
41
85
|
import pino from "pino";
|
|
42
86
|
|
|
43
|
-
const pinoLogger = pino(
|
|
87
|
+
const pinoLogger = pino({
|
|
88
|
+
level: "info",
|
|
89
|
+
transport: {
|
|
90
|
+
target: "pino-pretty",
|
|
91
|
+
options: {
|
|
92
|
+
colorize: true
|
|
93
|
+
}
|
|
94
|
+
}
|
|
95
|
+
});
|
|
44
96
|
|
|
45
97
|
await configure({
|
|
46
98
|
sinks: {
|
package/deno.json
CHANGED
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
//#region rolldown:runtime
|
|
2
|
+
var __create = Object.create;
|
|
3
|
+
var __defProp = Object.defineProperty;
|
|
4
|
+
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
5
|
+
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
6
|
+
var __getProtoOf = Object.getPrototypeOf;
|
|
7
|
+
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
8
|
+
var __copyProps = (to, from, except, desc) => {
|
|
9
|
+
if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
|
|
10
|
+
key = keys[i];
|
|
11
|
+
if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
|
|
12
|
+
get: ((k) => from[k]).bind(null, key),
|
|
13
|
+
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
|
|
14
|
+
});
|
|
15
|
+
}
|
|
16
|
+
return to;
|
|
17
|
+
};
|
|
18
|
+
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
|
|
19
|
+
value: mod,
|
|
20
|
+
enumerable: true
|
|
21
|
+
}) : target, mod));
|
|
22
|
+
|
|
23
|
+
//#endregion
|
|
24
|
+
|
|
25
|
+
Object.defineProperty(exports, '__toESM', {
|
|
26
|
+
enumerable: true,
|
|
27
|
+
get: function () {
|
|
28
|
+
return __toESM;
|
|
29
|
+
}
|
|
30
|
+
});
|
package/dist/mod.cjs
CHANGED
|
@@ -1,3 +1,5 @@
|
|
|
1
|
+
const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
|
|
2
|
+
const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
|
|
1
3
|
|
|
2
4
|
//#region mod.ts
|
|
3
5
|
/**
|
|
@@ -73,6 +75,70 @@ function getPinoSink(logger, options = {}) {
|
|
|
73
75
|
}
|
|
74
76
|
};
|
|
75
77
|
}
|
|
78
|
+
/**
|
|
79
|
+
* Automatically configures LogTape to route all logs to a Pino logger.
|
|
80
|
+
*
|
|
81
|
+
* This is a convenience function that automatically sets up LogTape to forward
|
|
82
|
+
* all log records to a Pino logger instance.
|
|
83
|
+
*
|
|
84
|
+
* @example Basic auto-configuration
|
|
85
|
+
* ```typescript
|
|
86
|
+
* import pino from "pino";
|
|
87
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
88
|
+
*
|
|
89
|
+
* const pinoLogger = pino();
|
|
90
|
+
*
|
|
91
|
+
* // Automatically route all LogTape logs to the Pino logger
|
|
92
|
+
* install(pinoLogger);
|
|
93
|
+
*
|
|
94
|
+
* // Now any LogTape-enabled library will log through Pino
|
|
95
|
+
* import { getLogger } from "@logtape/logtape";
|
|
96
|
+
* const logger = getLogger("my-app");
|
|
97
|
+
* logger.info("This will be logged through Pino");
|
|
98
|
+
* ```
|
|
99
|
+
*
|
|
100
|
+
* @example Auto-configuration with custom options
|
|
101
|
+
* ```typescript
|
|
102
|
+
* import pino from "pino";
|
|
103
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
104
|
+
*
|
|
105
|
+
* const pinoLogger = pino({
|
|
106
|
+
* level: "info",
|
|
107
|
+
* transport: {
|
|
108
|
+
* target: "pino-pretty"
|
|
109
|
+
* }
|
|
110
|
+
* });
|
|
111
|
+
*
|
|
112
|
+
* install(pinoLogger, {
|
|
113
|
+
* category: {
|
|
114
|
+
* position: "start",
|
|
115
|
+
* decorator: "[]",
|
|
116
|
+
* separator: "."
|
|
117
|
+
* }
|
|
118
|
+
* });
|
|
119
|
+
* ```
|
|
120
|
+
*
|
|
121
|
+
* @typeParam CustomLevels The custom log levels supported by the Pino logger.
|
|
122
|
+
* @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
|
|
123
|
+
* in the Pino logger.
|
|
124
|
+
* @param logger The Pino logger instance to forward logs to.
|
|
125
|
+
* @param options Configuration options for the sink adapter.
|
|
126
|
+
* @since 1.0.0
|
|
127
|
+
*/
|
|
128
|
+
function install(logger, options = {}) {
|
|
129
|
+
(0, __logtape_logtape.configureSync)({
|
|
130
|
+
sinks: { pino: getPinoSink(logger, options) },
|
|
131
|
+
loggers: [{
|
|
132
|
+
category: ["logtape", "meta"],
|
|
133
|
+
sinks: ["pino"],
|
|
134
|
+
lowestLevel: "warning"
|
|
135
|
+
}, {
|
|
136
|
+
category: [],
|
|
137
|
+
sinks: ["pino"]
|
|
138
|
+
}]
|
|
139
|
+
});
|
|
140
|
+
}
|
|
76
141
|
|
|
77
142
|
//#endregion
|
|
78
|
-
exports.getPinoSink = getPinoSink;
|
|
143
|
+
exports.getPinoSink = getPinoSink;
|
|
144
|
+
exports.install = install;
|
package/dist/mod.d.cts
CHANGED
|
@@ -87,7 +87,58 @@ interface CategoryOptions {
|
|
|
87
87
|
* @since 1.0.0
|
|
88
88
|
*/
|
|
89
89
|
declare function getPinoSink<CustomLevels extends string, UseOnlyCustomLevels extends boolean>(logger: Logger<CustomLevels, UseOnlyCustomLevels>, options?: PinoSinkOptions): Sink;
|
|
90
|
+
/**
|
|
91
|
+
* Automatically configures LogTape to route all logs to a Pino logger.
|
|
92
|
+
*
|
|
93
|
+
* This is a convenience function that automatically sets up LogTape to forward
|
|
94
|
+
* all log records to a Pino logger instance.
|
|
95
|
+
*
|
|
96
|
+
* @example Basic auto-configuration
|
|
97
|
+
* ```typescript
|
|
98
|
+
* import pino from "pino";
|
|
99
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
100
|
+
*
|
|
101
|
+
* const pinoLogger = pino();
|
|
102
|
+
*
|
|
103
|
+
* // Automatically route all LogTape logs to the Pino logger
|
|
104
|
+
* install(pinoLogger);
|
|
105
|
+
*
|
|
106
|
+
* // Now any LogTape-enabled library will log through Pino
|
|
107
|
+
* import { getLogger } from "@logtape/logtape";
|
|
108
|
+
* const logger = getLogger("my-app");
|
|
109
|
+
* logger.info("This will be logged through Pino");
|
|
110
|
+
* ```
|
|
111
|
+
*
|
|
112
|
+
* @example Auto-configuration with custom options
|
|
113
|
+
* ```typescript
|
|
114
|
+
* import pino from "pino";
|
|
115
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
116
|
+
*
|
|
117
|
+
* const pinoLogger = pino({
|
|
118
|
+
* level: "info",
|
|
119
|
+
* transport: {
|
|
120
|
+
* target: "pino-pretty"
|
|
121
|
+
* }
|
|
122
|
+
* });
|
|
123
|
+
*
|
|
124
|
+
* install(pinoLogger, {
|
|
125
|
+
* category: {
|
|
126
|
+
* position: "start",
|
|
127
|
+
* decorator: "[]",
|
|
128
|
+
* separator: "."
|
|
129
|
+
* }
|
|
130
|
+
* });
|
|
131
|
+
* ```
|
|
132
|
+
*
|
|
133
|
+
* @typeParam CustomLevels The custom log levels supported by the Pino logger.
|
|
134
|
+
* @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
|
|
135
|
+
* in the Pino logger.
|
|
136
|
+
* @param logger The Pino logger instance to forward logs to.
|
|
137
|
+
* @param options Configuration options for the sink adapter.
|
|
138
|
+
* @since 1.0.0
|
|
139
|
+
*/
|
|
140
|
+
declare function install<CustomLevels extends string, UseOnlyCustomLevels extends boolean>(logger: Logger<CustomLevels, UseOnlyCustomLevels>, options?: PinoSinkOptions): void;
|
|
90
141
|
//# sourceMappingURL=mod.d.ts.map
|
|
91
142
|
//#endregion
|
|
92
|
-
export { CategoryOptions, PinoSinkOptions, getPinoSink };
|
|
143
|
+
export { CategoryOptions, PinoSinkOptions, getPinoSink, install };
|
|
93
144
|
//# sourceMappingURL=mod.d.cts.map
|
package/dist/mod.d.cts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"mod.d.cts","names":[],"sources":["../mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;AAcA;AAqEgB,UAnFC,eAAA,CAmFU;EAAA;;;;;;EAMpB,SAAA,QAAA,CAAA,EAAA,OAAA,GAlFyB,eAkFzB
|
|
1
|
+
{"version":3,"file":"mod.d.cts","names":[],"sources":["../mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;AAcA;AAqEgB,UAnFC,eAAA,CAmFU;EAAA;;;;;;EAMpB,SAAA,QAAA,CAAA,EAAA,OAAA,GAlFyB,eAkFzB;AAqIP;;;;;AAKW,UArNM,eAAA,CAqNN;EAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAhJf,sFAIN,OAAO,cAAc,gCACpB,kBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqIa,kFAIN,OAAO,cAAc,gCACpB"}
|
package/dist/mod.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { Logger } from "pino";
|
|
2
1
|
import { Sink } from "@logtape/logtape";
|
|
2
|
+
import { Logger } from "pino";
|
|
3
3
|
|
|
4
4
|
//#region mod.d.ts
|
|
5
5
|
|
|
@@ -87,7 +87,58 @@ interface CategoryOptions {
|
|
|
87
87
|
* @since 1.0.0
|
|
88
88
|
*/
|
|
89
89
|
declare function getPinoSink<CustomLevels extends string, UseOnlyCustomLevels extends boolean>(logger: Logger<CustomLevels, UseOnlyCustomLevels>, options?: PinoSinkOptions): Sink;
|
|
90
|
+
/**
|
|
91
|
+
* Automatically configures LogTape to route all logs to a Pino logger.
|
|
92
|
+
*
|
|
93
|
+
* This is a convenience function that automatically sets up LogTape to forward
|
|
94
|
+
* all log records to a Pino logger instance.
|
|
95
|
+
*
|
|
96
|
+
* @example Basic auto-configuration
|
|
97
|
+
* ```typescript
|
|
98
|
+
* import pino from "pino";
|
|
99
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
100
|
+
*
|
|
101
|
+
* const pinoLogger = pino();
|
|
102
|
+
*
|
|
103
|
+
* // Automatically route all LogTape logs to the Pino logger
|
|
104
|
+
* install(pinoLogger);
|
|
105
|
+
*
|
|
106
|
+
* // Now any LogTape-enabled library will log through Pino
|
|
107
|
+
* import { getLogger } from "@logtape/logtape";
|
|
108
|
+
* const logger = getLogger("my-app");
|
|
109
|
+
* logger.info("This will be logged through Pino");
|
|
110
|
+
* ```
|
|
111
|
+
*
|
|
112
|
+
* @example Auto-configuration with custom options
|
|
113
|
+
* ```typescript
|
|
114
|
+
* import pino from "pino";
|
|
115
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
116
|
+
*
|
|
117
|
+
* const pinoLogger = pino({
|
|
118
|
+
* level: "info",
|
|
119
|
+
* transport: {
|
|
120
|
+
* target: "pino-pretty"
|
|
121
|
+
* }
|
|
122
|
+
* });
|
|
123
|
+
*
|
|
124
|
+
* install(pinoLogger, {
|
|
125
|
+
* category: {
|
|
126
|
+
* position: "start",
|
|
127
|
+
* decorator: "[]",
|
|
128
|
+
* separator: "."
|
|
129
|
+
* }
|
|
130
|
+
* });
|
|
131
|
+
* ```
|
|
132
|
+
*
|
|
133
|
+
* @typeParam CustomLevels The custom log levels supported by the Pino logger.
|
|
134
|
+
* @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
|
|
135
|
+
* in the Pino logger.
|
|
136
|
+
* @param logger The Pino logger instance to forward logs to.
|
|
137
|
+
* @param options Configuration options for the sink adapter.
|
|
138
|
+
* @since 1.0.0
|
|
139
|
+
*/
|
|
140
|
+
declare function install<CustomLevels extends string, UseOnlyCustomLevels extends boolean>(logger: Logger<CustomLevels, UseOnlyCustomLevels>, options?: PinoSinkOptions): void;
|
|
90
141
|
//# sourceMappingURL=mod.d.ts.map
|
|
91
142
|
//#endregion
|
|
92
|
-
export { CategoryOptions, PinoSinkOptions, getPinoSink };
|
|
143
|
+
export { CategoryOptions, PinoSinkOptions, getPinoSink, install };
|
|
93
144
|
//# sourceMappingURL=mod.d.ts.map
|
package/dist/mod.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"mod.d.ts","names":[],"sources":["../mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;AAcA;AAqEgB,UAnFC,eAAA,CAmFU;EAAA;;;;;;EAMpB,SAAA,QAAA,CAAA,EAAA,OAAA,GAlFyB,eAkFzB
|
|
1
|
+
{"version":3,"file":"mod.d.ts","names":[],"sources":["../mod.ts"],"sourcesContent":[],"mappings":";;;;;;;AAOA;AAcA;AAqEgB,UAnFC,eAAA,CAmFU;EAAA;;;;;;EAMpB,SAAA,QAAA,CAAA,EAAA,OAAA,GAlFyB,eAkFzB;AAqIP;;;;;AAKW,UArNM,eAAA,CAqNN;EAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAhJf,sFAIN,OAAO,cAAc,gCACpB,kBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqIa,kFAIN,OAAO,cAAc,gCACpB"}
|
package/dist/mod.js
CHANGED
|
@@ -1,3 +1,5 @@
|
|
|
1
|
+
import { configureSync } from "@logtape/logtape";
|
|
2
|
+
|
|
1
3
|
//#region mod.ts
|
|
2
4
|
/**
|
|
3
5
|
* Creates a LogTape sink that forwards log records to a Pino logger.
|
|
@@ -72,7 +74,70 @@ function getPinoSink(logger, options = {}) {
|
|
|
72
74
|
}
|
|
73
75
|
};
|
|
74
76
|
}
|
|
77
|
+
/**
|
|
78
|
+
* Automatically configures LogTape to route all logs to a Pino logger.
|
|
79
|
+
*
|
|
80
|
+
* This is a convenience function that automatically sets up LogTape to forward
|
|
81
|
+
* all log records to a Pino logger instance.
|
|
82
|
+
*
|
|
83
|
+
* @example Basic auto-configuration
|
|
84
|
+
* ```typescript
|
|
85
|
+
* import pino from "pino";
|
|
86
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
87
|
+
*
|
|
88
|
+
* const pinoLogger = pino();
|
|
89
|
+
*
|
|
90
|
+
* // Automatically route all LogTape logs to the Pino logger
|
|
91
|
+
* install(pinoLogger);
|
|
92
|
+
*
|
|
93
|
+
* // Now any LogTape-enabled library will log through Pino
|
|
94
|
+
* import { getLogger } from "@logtape/logtape";
|
|
95
|
+
* const logger = getLogger("my-app");
|
|
96
|
+
* logger.info("This will be logged through Pino");
|
|
97
|
+
* ```
|
|
98
|
+
*
|
|
99
|
+
* @example Auto-configuration with custom options
|
|
100
|
+
* ```typescript
|
|
101
|
+
* import pino from "pino";
|
|
102
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
103
|
+
*
|
|
104
|
+
* const pinoLogger = pino({
|
|
105
|
+
* level: "info",
|
|
106
|
+
* transport: {
|
|
107
|
+
* target: "pino-pretty"
|
|
108
|
+
* }
|
|
109
|
+
* });
|
|
110
|
+
*
|
|
111
|
+
* install(pinoLogger, {
|
|
112
|
+
* category: {
|
|
113
|
+
* position: "start",
|
|
114
|
+
* decorator: "[]",
|
|
115
|
+
* separator: "."
|
|
116
|
+
* }
|
|
117
|
+
* });
|
|
118
|
+
* ```
|
|
119
|
+
*
|
|
120
|
+
* @typeParam CustomLevels The custom log levels supported by the Pino logger.
|
|
121
|
+
* @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
|
|
122
|
+
* in the Pino logger.
|
|
123
|
+
* @param logger The Pino logger instance to forward logs to.
|
|
124
|
+
* @param options Configuration options for the sink adapter.
|
|
125
|
+
* @since 1.0.0
|
|
126
|
+
*/
|
|
127
|
+
function install(logger, options = {}) {
|
|
128
|
+
configureSync({
|
|
129
|
+
sinks: { pino: getPinoSink(logger, options) },
|
|
130
|
+
loggers: [{
|
|
131
|
+
category: ["logtape", "meta"],
|
|
132
|
+
sinks: ["pino"],
|
|
133
|
+
lowestLevel: "warning"
|
|
134
|
+
}, {
|
|
135
|
+
category: [],
|
|
136
|
+
sinks: ["pino"]
|
|
137
|
+
}]
|
|
138
|
+
});
|
|
139
|
+
}
|
|
75
140
|
|
|
76
141
|
//#endregion
|
|
77
|
-
export { getPinoSink };
|
|
142
|
+
export { getPinoSink, install };
|
|
78
143
|
//# sourceMappingURL=mod.js.map
|
package/dist/mod.js.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"mod.js","names":["logger: Logger<CustomLevels, UseOnlyCustomLevels>","options: PinoSinkOptions","category: Required<CategoryOptions> | undefined","record: LogRecord","interpolationValues: unknown[]"],"sources":["../mod.ts"],"sourcesContent":["import type { Logger } from \"pino\";\nimport type
|
|
1
|
+
{"version":3,"file":"mod.js","names":["logger: Logger<CustomLevels, UseOnlyCustomLevels>","options: PinoSinkOptions","category: Required<CategoryOptions> | undefined","record: LogRecord","interpolationValues: unknown[]"],"sources":["../mod.ts"],"sourcesContent":["import type { Logger } from \"pino\";\nimport { configureSync, type LogRecord, type Sink } from \"@logtape/logtape\";\n\n/**\n * Options for configuring the Pino sink adapter.\n * @since 1.0.0\n */\nexport interface PinoSinkOptions {\n /**\n * Configuration for how LogTape categories are handled in Pino logs.\n * - `false` or `undefined`: Categories are not included in the log message\n * - `true`: Categories are included with default formatting\n * - `CategoryOptions`: Custom category formatting configuration\n */\n readonly category?: boolean | CategoryOptions;\n}\n\n/**\n * Configuration options for formatting LogTape categories in Pino log messages.\n * @since 1.0.0\n */\nexport interface CategoryOptions {\n /**\n * The separator used to join category parts when multiple categories exist.\n * @default \"·\"\n */\n readonly separator?: string;\n\n /**\n * Where to position the category in the log message.\n * - `\"start\"`: Category appears at the beginning of the message\n * - `\"end\"`: Category appears at the end of the message\n * @default \"start\"\n */\n readonly position?: \"start\" | \"end\";\n\n /**\n * The decorator used to format the category in the log message.\n * - `\"[]\"`: [category] format\n * - `\"()\"`: (category) format\n * - `\"<>\"`: <category> format\n * - `\"{}\"`: {category} format\n * - `\":\"`: category: format\n * - `\"-\"`: category - format\n * - `\"|\"`: category | format\n * - `\"/\"`: category / format\n * - `\"\"`: category format (no decoration)\n * @default \":\"\n */\n readonly decorator?: \"[]\" | \"()\" | \"<>\" | \"{}\" | \":\" | \"-\" | \"|\" | \"/\" | \"\";\n}\n\n/**\n * Creates a LogTape sink that forwards log records to a Pino logger.\n *\n * This adapter allows LogTape-enabled libraries to integrate seamlessly with\n * applications that use Pino for logging.\n *\n * @example\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getPinoSink } from \"@logtape/adaptor-pino\";\n * import pino from \"pino\";\n *\n * const pinoLogger = pino();\n *\n * await configure({\n * sinks: {\n * pino: getPinoSink(pinoLogger, {\n * category: {\n * position: \"start\",\n * decorator: \"[]\",\n * separator: \".\"\n * }\n * })\n * },\n * loggers: [\n * { category: \"my-library\", sinks: [\"pino\"] }\n * ]\n * });\n * ```\n *\n * @typeParam CustomLevels The custom log levels supported by the Pino logger.\n * @typeParam UseOnlyCustomLevels Whether to use only custom levels defined\n * in the Pino logger.\n * @param logger The Pino logger instance to forward logs to.\n * @param options Configuration options for the sink adapter.\n * @returns A LogTape sink function that can be used in LogTape configuration.\n * @since 1.0.0\n */\nexport function getPinoSink<\n CustomLevels extends string,\n UseOnlyCustomLevels extends boolean,\n>(\n logger: Logger<CustomLevels, UseOnlyCustomLevels>,\n options: PinoSinkOptions = {},\n): Sink {\n const categoryOptions = !options.category\n ? undefined\n : typeof options.category === \"object\"\n ? options.category\n : {};\n const category: Required<CategoryOptions> | undefined =\n categoryOptions == null ? undefined : {\n separator: categoryOptions.separator ?? \"·\",\n position: categoryOptions.position ?? \"start\",\n decorator: categoryOptions.decorator ?? \":\",\n };\n return (record: LogRecord) => {\n let message = \"\";\n const interpolationValues: unknown[] = [];\n if (category?.position === \"start\" && record.category.length > 0) {\n message += category.decorator === \"[]\"\n ? \"[%s] \"\n : category.decorator === \"()\"\n ? \"(%s) \"\n : category.decorator === \"<>\"\n ? \"<%s> \"\n : category.decorator === \"{}\"\n ? \"{%s} \"\n : category.decorator === \":\"\n ? \"%s: \"\n : category.decorator === \"-\"\n ? \"%s - \"\n : category.decorator === \"|\"\n ? \"%s | \"\n : category.decorator === \"/\"\n ? \"%s / \"\n : \"%s \";\n interpolationValues.push(\n record.category.join(category.separator),\n );\n }\n for (let i = 0; i < record.message.length; i += 2) {\n message += record.message[i];\n if (i + 1 < record.message.length) {\n message += \"%o\";\n interpolationValues.push(record.message[i + 1]);\n }\n }\n if (category?.position === \"end\" && record.category.length > 0) {\n message += category.decorator === \"[]\"\n ? \" [%s]\"\n : category.decorator === \"()\"\n ? \" (%s)\"\n : category.decorator === \"<>\"\n ? \" <%s>\"\n : category.decorator === \"{}\"\n ? \" {%s}\"\n : category.decorator === \":\"\n ? \": %s\"\n : category.decorator === \"-\"\n ? \" - %s\"\n : category.decorator === \"|\"\n ? \" | %s\"\n : category.decorator === \"/\"\n ? \" / %s\"\n : \" %s\";\n interpolationValues.push(\n record.category.join(category.separator),\n );\n }\n switch (record.level) {\n case \"trace\":\n return logger.trace(record.properties, message, interpolationValues);\n case \"debug\":\n return logger.debug(record.properties, message, interpolationValues);\n case \"info\":\n return logger.info(record.properties, message, interpolationValues);\n case \"warning\":\n return logger.warn(record.properties, message, interpolationValues);\n case \"error\":\n return logger.error(record.properties, message, interpolationValues);\n case \"fatal\":\n return logger.fatal(record.properties, message, interpolationValues);\n }\n };\n}\n\n/**\n * Automatically configures LogTape to route all logs to a Pino logger.\n *\n * This is a convenience function that automatically sets up LogTape to forward\n * all log records to a Pino logger instance.\n *\n * @example Basic auto-configuration\n * ```typescript\n * import pino from \"pino\";\n * import { install } from \"@logtape/adaptor-pino\";\n *\n * const pinoLogger = pino();\n *\n * // Automatically route all LogTape logs to the Pino logger\n * install(pinoLogger);\n *\n * // Now any LogTape-enabled library will log through Pino\n * import { getLogger } from \"@logtape/logtape\";\n * const logger = getLogger(\"my-app\");\n * logger.info(\"This will be logged through Pino\");\n * ```\n *\n * @example Auto-configuration with custom options\n * ```typescript\n * import pino from \"pino\";\n * import { install } from \"@logtape/adaptor-pino\";\n *\n * const pinoLogger = pino({\n * level: \"info\",\n * transport: {\n * target: \"pino-pretty\"\n * }\n * });\n *\n * install(pinoLogger, {\n * category: {\n * position: \"start\",\n * decorator: \"[]\",\n * separator: \".\"\n * }\n * });\n * ```\n *\n * @typeParam CustomLevels The custom log levels supported by the Pino logger.\n * @typeParam UseOnlyCustomLevels Whether to use only custom levels defined\n * in the Pino logger.\n * @param logger The Pino logger instance to forward logs to.\n * @param options Configuration options for the sink adapter.\n * @since 1.0.0\n */\nexport function install<\n CustomLevels extends string,\n UseOnlyCustomLevels extends boolean,\n>(\n logger: Logger<CustomLevels, UseOnlyCustomLevels>,\n options: PinoSinkOptions = {},\n): void {\n configureSync({\n sinks: {\n pino: getPinoSink(logger, options),\n },\n loggers: [\n {\n category: [\"logtape\", \"meta\"],\n sinks: [\"pino\"],\n lowestLevel: \"warning\",\n },\n { category: [], sinks: [\"pino\"] },\n ],\n });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0FA,SAAgB,YAIdA,QACAC,UAA2B,CAAE,GACvB;CACN,MAAM,mBAAmB,QAAQ,2BAEtB,QAAQ,aAAa,WAC5B,QAAQ,WACR,CAAE;CACN,MAAMC,WACJ,mBAAmB,gBAAmB;EACpC,WAAW,gBAAgB,aAAa;EACxC,UAAU,gBAAgB,YAAY;EACtC,WAAW,gBAAgB,aAAa;CACzC;AACH,QAAO,CAACC,WAAsB;EAC5B,IAAI,UAAU;EACd,MAAMC,sBAAiC,CAAE;AACzC,MAAI,UAAU,aAAa,WAAW,OAAO,SAAS,SAAS,GAAG;AAChE,cAAW,SAAS,cAAc,OAC9B,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,MACvB,SACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA;AACJ,uBAAoB,KAClB,OAAO,SAAS,KAAK,SAAS,UAAU,CACzC;EACF;AACD,OAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,QAAQ,KAAK,GAAG;AACjD,cAAW,OAAO,QAAQ;AAC1B,OAAI,IAAI,IAAI,OAAO,QAAQ,QAAQ;AACjC,eAAW;AACX,wBAAoB,KAAK,OAAO,QAAQ,IAAI,GAAG;GAChD;EACF;AACD,MAAI,UAAU,aAAa,SAAS,OAAO,SAAS,SAAS,GAAG;AAC9D,cAAW,SAAS,cAAc,OAC9B,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,OACvB,UACA,SAAS,cAAc,MACvB,SACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA,SAAS,cAAc,MACvB,UACA;AACJ,uBAAoB,KAClB,OAAO,SAAS,KAAK,SAAS,UAAU,CACzC;EACF;AACD,UAAQ,OAAO,OAAf;GACE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;GACtE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;GACtE,KAAK,OACH,QAAO,OAAO,KAAK,OAAO,YAAY,SAAS,oBAAoB;GACrE,KAAK,UACH,QAAO,OAAO,KAAK,OAAO,YAAY,SAAS,oBAAoB;GACrE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;GACtE,KAAK,QACH,QAAO,OAAO,MAAM,OAAO,YAAY,SAAS,oBAAoB;EACvE;CACF;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoDD,SAAgB,QAIdJ,QACAC,UAA2B,CAAE,GACvB;AACN,eAAc;EACZ,OAAO,EACL,MAAM,YAAY,QAAQ,QAAQ,CACnC;EACD,SAAS,CACP;GACE,UAAU,CAAC,WAAW,MAAO;GAC7B,OAAO,CAAC,MAAO;GACf,aAAa;EACd,GACD;GAAE,UAAU,CAAE;GAAE,OAAO,CAAC,MAAO;EAAE,CAClC;CACF,EAAC;AACH"}
|
package/mod.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import type { Logger } from "pino";
|
|
2
|
-
import type
|
|
2
|
+
import { configureSync, type LogRecord, type Sink } from "@logtape/logtape";
|
|
3
3
|
|
|
4
4
|
/**
|
|
5
5
|
* Options for configuring the Pino sink adapter.
|
|
@@ -176,3 +176,75 @@ export function getPinoSink<
|
|
|
176
176
|
}
|
|
177
177
|
};
|
|
178
178
|
}
|
|
179
|
+
|
|
180
|
+
/**
|
|
181
|
+
* Automatically configures LogTape to route all logs to a Pino logger.
|
|
182
|
+
*
|
|
183
|
+
* This is a convenience function that automatically sets up LogTape to forward
|
|
184
|
+
* all log records to a Pino logger instance.
|
|
185
|
+
*
|
|
186
|
+
* @example Basic auto-configuration
|
|
187
|
+
* ```typescript
|
|
188
|
+
* import pino from "pino";
|
|
189
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
190
|
+
*
|
|
191
|
+
* const pinoLogger = pino();
|
|
192
|
+
*
|
|
193
|
+
* // Automatically route all LogTape logs to the Pino logger
|
|
194
|
+
* install(pinoLogger);
|
|
195
|
+
*
|
|
196
|
+
* // Now any LogTape-enabled library will log through Pino
|
|
197
|
+
* import { getLogger } from "@logtape/logtape";
|
|
198
|
+
* const logger = getLogger("my-app");
|
|
199
|
+
* logger.info("This will be logged through Pino");
|
|
200
|
+
* ```
|
|
201
|
+
*
|
|
202
|
+
* @example Auto-configuration with custom options
|
|
203
|
+
* ```typescript
|
|
204
|
+
* import pino from "pino";
|
|
205
|
+
* import { install } from "@logtape/adaptor-pino";
|
|
206
|
+
*
|
|
207
|
+
* const pinoLogger = pino({
|
|
208
|
+
* level: "info",
|
|
209
|
+
* transport: {
|
|
210
|
+
* target: "pino-pretty"
|
|
211
|
+
* }
|
|
212
|
+
* });
|
|
213
|
+
*
|
|
214
|
+
* install(pinoLogger, {
|
|
215
|
+
* category: {
|
|
216
|
+
* position: "start",
|
|
217
|
+
* decorator: "[]",
|
|
218
|
+
* separator: "."
|
|
219
|
+
* }
|
|
220
|
+
* });
|
|
221
|
+
* ```
|
|
222
|
+
*
|
|
223
|
+
* @typeParam CustomLevels The custom log levels supported by the Pino logger.
|
|
224
|
+
* @typeParam UseOnlyCustomLevels Whether to use only custom levels defined
|
|
225
|
+
* in the Pino logger.
|
|
226
|
+
* @param logger The Pino logger instance to forward logs to.
|
|
227
|
+
* @param options Configuration options for the sink adapter.
|
|
228
|
+
* @since 1.0.0
|
|
229
|
+
*/
|
|
230
|
+
export function install<
|
|
231
|
+
CustomLevels extends string,
|
|
232
|
+
UseOnlyCustomLevels extends boolean,
|
|
233
|
+
>(
|
|
234
|
+
logger: Logger<CustomLevels, UseOnlyCustomLevels>,
|
|
235
|
+
options: PinoSinkOptions = {},
|
|
236
|
+
): void {
|
|
237
|
+
configureSync({
|
|
238
|
+
sinks: {
|
|
239
|
+
pino: getPinoSink(logger, options),
|
|
240
|
+
},
|
|
241
|
+
loggers: [
|
|
242
|
+
{
|
|
243
|
+
category: ["logtape", "meta"],
|
|
244
|
+
sinks: ["pino"],
|
|
245
|
+
lowestLevel: "warning",
|
|
246
|
+
},
|
|
247
|
+
{ category: [], sinks: ["pino"] },
|
|
248
|
+
],
|
|
249
|
+
});
|
|
250
|
+
}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@logtape/adaptor-pino",
|
|
3
|
-
"version": "1.0.0-dev.
|
|
3
|
+
"version": "1.0.0-dev.262+96c86667",
|
|
4
4
|
"description": "Pino adapter for LogTape logging library",
|
|
5
5
|
"keywords": [
|
|
6
6
|
"logging",
|
|
@@ -47,7 +47,7 @@
|
|
|
47
47
|
"sideEffects": false,
|
|
48
48
|
"peerDependencies": {
|
|
49
49
|
"pino": "^9.7.0",
|
|
50
|
-
"@logtape/logtape": "1.0.0-dev.
|
|
50
|
+
"@logtape/logtape": "1.0.0-dev.262+96c86667"
|
|
51
51
|
},
|
|
52
52
|
"devDependencies": {
|
|
53
53
|
"@alinea/suite": "^0.6.3",
|