How to use the connect.logger function in connect

} catch (e) {
  console.error('Unable to open config module/file ' + configPath);
  process.exit(1);
}


// App
//
var app = connect();



// Use the logger if environment config allows
//
if (config.log) {
  app.use(connect.logger('dev'));
}



// Append connect middleware
//
app.use(connect.query());
app.use(connect.json());



// Defines support for res.json in controller
// actions
//
// @req   {Object}    The http request object
// @res   {Object}    The http response object

sessions.run[id].write('data: ' + req.body.data + '\neventId:' + (++eventid) + '\n\n');

      if (sessions.run[id].xhr) {
        sessions.run[id].end(); // lets older browsers finish their xhr request
      }
    }
    res.writeHead(200, { 'Content-Type' : 'text/plain' });
    res.end();
  });
}

// connect.static.mime.define('text/cache-manifest', ['appcache']);

var server = connect.createServer(
  connect.bodyParser(),
  connect.logger(),
  connect.static(__dirname),
  connect.router(remoteServer)
);

console.log('Listening on ' + port);
server.listen(port);

next();
  })
  .use('/jest/blog/feed.xml', (req, res) => {
    res.end(
      fs.readFileSync(path.join(FILE_SERVE_ROOT, 'jest/blog/feed.xml')) + ''
    );
  })
  .use('/jest/blog/atom.xml', (req, res) => {
    res.end(
      fs.readFileSync(path.join(FILE_SERVE_ROOT, 'jest/blog/atom.xml')) + ''
    );
  })
  .use(reactMiddleware.provide(buildOptions))
  .use(connect['static'](FILE_SERVE_ROOT))
  // .use(connect.favicon(path.join(FILE_SERVE_ROOT, 'elements', 'favicon', 'favicon.ico')))
  .use(connect.logger())
  .use(connect.compress())
  .use(connect.errorHandler());

const portToUse = port || 8080;
const server = http.createServer(app);
server.listen(portToUse);
console.log('Open http://localhost:' + portToUse + '/jest/index.html');
module.exports = server;

var wsProxy = null;
  const app = connect()
    .use(loadRawBodyMiddleware)
    .use(connect.compress())
    .use(getDevToolsMiddleware(args, () => wsProxy && wsProxy.isChromeConnected()))
    .use(openStackFrameInEditorMiddleware)
    .use(statusPageMiddleware)
    .use(systraceProfileMiddleware)
    .use(cpuProfilerMiddleware)
    // Temporarily disable flow check until it's more stable
    //.use(getFlowTypeCheckMiddleware(args))
    .use(getAppMiddleware(args, config));

  args.projectRoots.forEach(root => app.use(connect.static(root)));

  app.use(connect.logger())
    .use(connect.errorHandler());

  const serverInstance = http.createServer(app).listen(
    args.port,
    '::',
    function() {
      wsProxy = webSocketProxy.attachToServer(serverInstance, '/debugger-proxy');
      webSocketProxy.attachToServer(serverInstance, '/devtools');
      readyCallback();
    }
  );
  // Disable any kind of automatic timeout behavior for incoming
  // requests in case it takes the packager more than the default
  // timeout of 120 seconds to respond to a request.
  serverInstance.timeout = 0;
}

return req.query;
    }
  };

  var router = makeRouter(
    routes.getRoutes(app),
    routes.getNotFound(app)
  );

  router.go(app.getPath());
}

// Set up the application and run it
var server = connect()
  .use(connect.static(__dirname + '/build'))
  .use(connect.logger())
  .use(connect.cookieParser())
  .use(connect.cookieSession({
    secret: IRLMOJI_COOKIE_SECRET,
    cookie: {
      maxAge: 365 * 24 * 60 * 60 * 1000, // 1 year in seconds, doesn't work tho
      proxy: true
    }
  }))
  .use(fixConnectCookieSessionHandler)
  .use(guestHandler)
  .use(connect.csrf())
  .use(apiProxyHandler)
  .use(connect.urlencoded())
  .use(connect.query())
  .use(connect.json())
  .use(logoutHandler)

var connect = require('connect');
var path = require('path');

var server = connect();
server.use(connect.logger());
server.use(connect.static(path.resolve(__dirname, '..')));
server.listen(8080);

var user = require('./controllers/user');
var post = require('./controllers/post');
var comment = require('./controllers/comment');
var tag = require('./controllers/tag');
var config = require('./config');
var utils = require('./lib/utils');
var Store = require('./lib/session_store');
var db = require('./db');

if (!config.view_theme) {
  config.view_theme = 'simple';
}
var qsOptions = { limit: 100 };
var app = connect(
  connect.static(__dirname + '/public'),
  connect.logger(),
  connect.cookieParser(),
  connect.bodyParser(qsOptions),
  connect.session({ 
    secret: config.session_secret,
    cookie:{ path: '/', httpOnly: true, maxAge: 24 * 3600000 * 3650 },
    store: new Store(config.db_options)
  }),
  connect.query(qsOptions),
  user.oauth_handle,
  render({
    root: __dirname + '/views/'+config.view_theme,
    cache: config.view_cache || false,
    helpers: {
      config: config,
      markdown: utils.markdown,
      first_paragraph_markdown: utils.first_paragraph_markdown

var server;

  var connect = require('connect'),
      express = require('express');

  var app = express();

  if(typeof options.root !== 'undefined') {
    app
      .use(connect.static(options.root))
      .use(connect.directory(options.root));
  }

  app
    .use(connect.favicon())
    .use(connect.logger('dev'))
    .use(connect.cookieParser())
    .use(connect.session({ secret: 'my secret here' }));

  if(options.enableUploads === true) {
    app
    .use(express.bodyParser({
      uploadDir: __dirname + '/uploads',
      keepExtensions: true
    }));
  }


   http.server = server = require('http').createServer(app).listen(options.port, options.host, function(){
      callback(null, server);
   });
   http.app = app;

var owin = require('connect-owin'),
    connect = require('connect'),
    express = require('express');

var app = express();
app.use(connect.logger('dev'));
//app.use(express.compress());
app.all('/api/*', owin(__dirname + '/bin/Debug/Samples.WebApi.dll'));
app.use(express.static('Site'));
app.listen(3000);