I have a fluentbit running in the Docker container 192.168.1.201:24224 which is connected to the elasticsearch.
Now, I am trying to connect my nestjs logger to the fluentbit:
logger.ts
import * as winston from 'winston';
var config = {
host: '192.168.1.201',
port: 24224,
timeout: 3.0,
requireAckResponse: true, // Add this option to wait response from Fluentd certainly
};
var fluentTransport = require('fluent-logger').support.winstonTransport();
var fluent = new fluentTransport('test', config);
// Initialize Winston Logger
const logger = winston.createLogger({
level: 'verbose',
format: winston.format.json(),
defaultMeta: { service: 'test-service' },
transports: [
fluent,
new winston.transports.Console({
format: winston.format.json(),
}),
],
});
export default logger;
I am using the logger in this way:
loggservice.ts:
async log_info(
tracking_id: any,
) {
logger.log({
tracking_id: tracking_id,
});
}
then, in the function :
test.ts:
log_info(tracking_id)
It seems that it can not send the log to the fluentbit(so that I can get the log in ES), am I missing something here?
Related
i was reading through the winston documentation and I came across the following statement
A transport is essentially a storage device for your logs
So I assumed if i set up a http transport i would be able to aggregate the logs somewhere else. In my case in an application running in localhost:3210
Does anybody know why I'm not receiving the log I'm trying to send ?
Here is my code:
import { createLogger, format, transports } from 'winston';
const { combine, timestamp, label, printf} = format;
const myFormat = printf(({ level, message, label, timestamp }) => {
return `${timestamp} [${label}] ${level}: ${message}`;
});
export const logger = createLogger({
format: combine(label({ label: 'Test Service' }), timestamp(), myFormat),
transports: [
new transports.Http({
host: 'localhost',
port: 3210,
path: '/'
})
]
});
logger.log({
level: 'info',
message: `Hello there`
});
Try logger.info('Hello there');. Also, no idea how your server looks like, but make sure it has a defined POST method with the required path.
I can access to the winston logger exposer by parse-server with let logger = require('parse-server').logger;
I would like to configure several transport file to have separate file with different logging levels like I can do with Winston:
var logger = new (winston.Logger)({
transports: [
new (winston.transports.File)({
name: 'info-file',
filename: 'filelog-info.log',
level: 'info'
}),
new (winston.transports.File)({
name: 'silly-file',
filename: 'filelog-silly.log',
level: 'silly'
})
]
});
I've tried by usgin winston function like:
logger.add(winston.transports.File, { ... });
And with:
winston.configure({
transports: [
new (winston.transports.File)({ filename: 'somefile.log' })
]
});
But it doesn't work.
I also saw this PR https://github.com/parse-community/parse-server/pull/2363 but I coudn't understand how to add these transports from my index.js in parse-server.
Can someone give me some hints? Thanks!
Additional info:
parse-server version: 2.6.2
I was trying to do similar as you. I wanted to add a transport to send logs to loggly.
I think the way to do it, is to use the logger object, that is exported together with the ParseServer object from the parse-server package.
The way how I added the loggly additional transport is the following:
const {ParseServer, logger} = require('parse-server');
const loggly = require('winston-loggly');
const parseApi = new ParseServer({
...
});
logger.adapter.addTransport(new loggly.Loggly({
subdomain: 'my-subdomain',
token: 'myToken',
json: true
}));
I believe this is safe to do, as the logger is exported by the package in the same way as ParseServer.
Hope it helps. Lukas
for future reference (an example how I use winston-mongoDB), I'll just add my way as well:
1) create custom logger adapter
var _WinstonLoggerAdapter = require('parse-server/lib/Adapters/Logger/WinstonLoggerAdapter');
import * as WinstonMongoDb from 'winston-mongodb';
export function createCustomLoggerAdapter(options) {
var winston = new _WinstonLoggerAdapter.WinstonLoggerAdapter(options);
var WinstonMongoDbInstance: any = WinstonMongoDb.MongoDB;
const transport = new WinstonMongoDbInstance({
...options,
collection: 'ServerLog',
level: 'error'
});
winston.addTransport(transport);
return winston;
}
2) use it in parse config
var parseConfig = {
....,
loggerAdapter: createCustomLoggerAdapter({db: databaseUri}),
}
I am confused by winston. I am using the following typescript code to log onto the console in my *.ts file:
import { Logger, LoggerInstance } from "winston";
const logger:LoggerInstance = new Logger();
logger.info('Now my debug messages are written to the console!');
the console remains empty. There are no compile errors or other issues.
At the same time the following works fine:
const wnstn = require("winston");
wnstn.info('Finally my messages are written to the console!');
Does anyone have a clue why that is the case? Do I have to configure the Logger differently? How would I use the defaults I get from the second example?
This is the Typescript way to import Winston.
First, be sure you have installed the typing :
npm i -D #types/winston
Then, in your script.ts
import { Logger, transports } from 'winston';
var logger = new Logger({
transports: [
new transports.Console(),
new transports.File ({ filename: 'somefile.log' })
]
});
In genral, you can import all constants and types without using winston.<...> before.
When you instantiate a new Logger instance you need to provide it a list of transports so it knows where to send the logs:
var logger = new (winston.Logger)({
transports: [
new (winston.transports.Console)(),
new (winston.transports.File)({ filename: 'somefile.log' })
]
});
Well,
thanks to the hint of #idbehold , I found that a plain and easy:
import * as winston from "winston";
winston.info('Now my debug messages are written to the console!');
works for the default logger..
Well, I am following below file as winston.ts
import * as appRoot from 'app-root-path';
import * as winston from 'winston';
// define the custom settings for each transport (file, console)
const options = {
file: {
level: 'info',
filename: `${appRoot}/logs/app.log`,
handleExceptions: true,
json: true,
maxsize: 5242880, // 5MB
maxFiles: 5,
colorize: false,
},
console: {
level: 'debug',
handleExceptions: true,
json: false,
colorize: true,
},
};
// instantiate a new Winston Logger with the settings defined above
const logger: winston.Logger = winston.createLogger({
transports: [
new winston.transports.File(options.file),
new winston.transports.Console(options.console)
],
exitOnError: false, // do not exit on handled exceptions
});
// create a stream object with a 'write' function that will be used by `morgan`
const myStream = {
write: (message: string) => {
// use the 'info' log level so the output will be picked up by both transports (file and console)
logger.info(message);
}
};
export default logger;
as using inside app.ts as this.app.use(morgan('combined', { stream: winston.stream }));
I am using winston logger in my node app and i want to log my custom message to the log file.
var logger = new winston.Logger({
transports: [
new winston.transports.File({
level: 'info',
filename: '/tmp/test.log',
handleExceptions: true,
json: true,
maxsize: 20971520 //20MB
})
],
exitOnError: false
});
I only need to log message in the log, i dont need to log level and timestamp in the log file. Current logged sample is as below.
{"level":"info","message":"sample entry to log","timestamp":"2015-12-11T09:43:50.507Z"}
My intention is to get entry in the log file as below
sample entry to log
How to achieve this?
Winston 3:
import winston from 'winston';
const logger = winston.createLogger({
level: 'info',
transports: [
new winston.transports.Console({
format: winston.format.printf(log => log.message),
})
]
});
logger.info('eat my shorts');
On Winston 2.x
If you want to print only the message, you can achieve this by setting:
json: false,
timestamp: false,
showLevel: false
Full Logger example:
let logger = new Logger({
transports: [
new (transports.File)({
name: 'info-file',
filename: 'filelog-info.log',
json: false,
timestamp: false,
showLevel: false
})
],
exitOnError: false
});
logger.log('info', 'eat my shorts');
gives in filelog-info.log: eat my shorts
FYI: filters and rewriters didn't help here
If anyone, as did I, finds this question in hopes of making express-winston log only message (to the console in my case)
Here is what I did:
const winston = require('winston');
const expressWinston = require('express-winston');
const { MESSAGE } = require('triple-beam');
expressWinston.logger({
transports: [
new winston.transports.Console({
format: simpleformatter()
})
]
});
const simpleformatter = winston.format(info => {
info[MESSAGE] = info.message;
return info;
});
Yep got the one i was looking for
https://github.com/winstonjs/winston#filters-and-rewriters
https://github.com/winstonjs/winston#custom-log-format
I am currently trying to write a custom logger for sailsjs that will use winston to send files to either an s3 bucket or a mongodb database.
The documentation seems to be lacking but so far i have found this:
var customLogger = new winston.Logger({
transports: [
new(winston.transports.File)({
level: 'debug',
filename: './logs/my_log_file.log'
})
]
});
module.exports.log = {
colors: false, // To get clean logs without prefixes or color codings
custom: customLogger
};
Which overall is not working for me.
Any ideas?
After extending above MayBeColin's work, the working solution:
Create a new js file inside a config folder(code inside of this will be executed automatically by sails) and add mongodb transports as below,
var winston = require('winston');
var MongoDB = require('winston-mongodb').MongoDB;
var customLogger = new(winston.Logger)({
transports: [
new(winston.transports.MongoDB)({
db: 'mongodb://localhost:27017/test',
collection: 'logs',
level: 'debug'
})
]
});
module.exports.logging = {
colors: false, // To get clean logs without prefixes or color codings
custom: customLogger
};
And use it anywhere like
sails.config.logging.custom.debug("winston mongodb transport logging");