Hugging Face's logo

Spaces:
hstz
/
ai
Running

App Files Community
ai
File size: 3,454 Bytes 
3b6afc0
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
const pino = require('pino');

const logger = pino({
  level: 'info',
  redact: {
    paths: [
      // List of Paths to redact from the logs (https://getpino.io/#/docs/redaction)
      'env.OPENAI_API_KEY',
      'env.BINGAI_TOKEN',
      'env.CHATGPT_TOKEN',
      'env.MEILI_MASTER_KEY',
      'env.GOOGLE_CLIENT_SECRET',
      'env.JWT_SECRET',
      'env.JWT_SECRET_DEV',
      'env.JWT_SECRET_PROD',
      'newUser.password',
    ], // See example to filter object class instances
    censor: '***', // Redaction character
  },
});

// Sanitize outside the logger paths. This is useful for sanitizing variables directly with Regex and patterns.
const redactPatterns = [
  // Array of regular expressions for redacting patterns
  /api[-_]?key/i,
  /password/i,
  /token/i,
  /secret/i,
  /key/i,
  /certificate/i,
  /client[-_]?id/i,
  /authorization[-_]?code/i,
  /authorization[-_]?login[-_]?hint/i,
  /authorization[-_]?acr[-_]?values/i,
  /authorization[-_]?response[-_]?mode/i,
  /authorization[-_]?nonce/i,
];

/*
  // Example of redacting sensitive data from object class instances
  function redactSensitiveData(obj) {
    if (obj instanceof User) {
      return {
        ...obj.toObject(),
        password: '***', // Redact the password field
      };
    }
    return obj;
  }

  // Example of redacting sensitive data from object class instances
  logger.info({ newUser: redactSensitiveData(newUser) }, 'newUser');
*/

const levels = {
  TRACE: 10,
  DEBUG: 20,
  INFO: 30,
  WARN: 40,
  ERROR: 50,
  FATAL: 60,
};

let level = levels.INFO;

module.exports = {
  levels,
  setLevel: (l) => (level = l),
  log: {
    trace: (msg) => {
      if (level <= levels.TRACE) {
        return;
      }
      logger.trace(msg);
    },
    debug: (msg) => {
      if (level <= levels.DEBUG) {
        return;
      }
      logger.debug(msg);
    },
    info: (msg) => {
      if (level <= levels.INFO) {
        return;
      }
      logger.info(msg);
    },
    warn: (msg) => {
      if (level <= levels.WARN) {
        return;
      }
      logger.warn(msg);
    },
    error: (msg) => {
      if (level <= levels.ERROR) {
        return;
      }
      logger.error(msg);
    },
    fatal: (msg) => {
      if (level <= levels.FATAL) {
        return;
      }
      logger.fatal(msg);
    },

    // Custom loggers
    parameters: (parameters) => {
      if (level <= levels.TRACE) {
        return;
      }
      logger.debug({ parameters }, 'Function Parameters');
    },
    functionName: (name) => {
      if (level <= levels.TRACE) {
        return;
      }
      logger.debug(`EXECUTING: ${name}`);
    },
    flow: (flow) => {
      if (level <= levels.INFO) {
        return;
      }
      logger.debug(`BEGIN FLOW: ${flow}`);
    },
    variable: ({ name, value }) => {
      if (level <= levels.DEBUG) {
        return;
      }
      // Check if the variable name matches any of the redact patterns and redact the value
      let sanitizedValue = value;
      for (const pattern of redactPatterns) {
        if (pattern.test(name)) {
          sanitizedValue = '***';
          break;
        }
      }
      logger.debug({ variable: { name, value: sanitizedValue } }, `VARIABLE ${name}`);
    },
    request: () => (req, res, next) => {
      if (level < levels.DEBUG) {
        return next();
      }
      logger.debug({ query: req.query, body: req.body }, `Hit URL ${req.url} with following`);
      return next();
    },
  },
};