Sails Memory Leak or Keep increasing

I have created a new sails js app and did not change any code in it.
Than I used pm2 to launch two instance of that app. Memory keep increasing without hitting app even once.
I have done the same with basic express.js app with following code but it does not increase memory
"
var express =  require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Hello World!');
});
var server = app.listen(3000, function () {
var host = server.address().address;
var port = server.address().port;
console.log('Example app listening at http://%s:%s', host, port);
});
"

Interesting. Is it running migrations?

It is not doing anything. All I did is
sails new demo
cd demo
pm2 start app.js -i 2 --name "sailsApp"
And now it was increased further, I have not touch or used that app at all. Why the memory would increase.

And memory has increased to:

Without using it at all.
Can someone please help

Approximately how long does it take for the memory to grow to that level? Are we talking minutes, hours, or days?
Does this only happen when in cluster mode? If not, what happens if you start by command line without pm2?

Above levels took about 2 - 3 hrs to grow but if you keep looking at it, you can see memory growing in MBs.
And following is the picture after leaving it overnight.

I will test forked mode now to compare if I am getting same results or not.
And also will run it without pm2.

@shumailarshad Thank you for going the extra mile! This is important information.

After testing fork mode for 3 hours, I found out that the problem is only cluster mode. It is some problem with sails js as express working with pm2 in cluster mode absolutely fine.

Maybe the grunt hook gets crazy in cluster mode? Try to start the sails app in cluster mode disabling the grunt hook, in the .sailsrc file, and take a look.

@Josebaseba read my mind, I was wondering the same thing. :+1:

How to disable grunt hook. Can you please help? Or may be how to disable sails modules which I will not be using at all.

Change the .sailsrc file to:
{
  "hooks": {
    "grunt": false
  }
}

I have disabled grunt and tried again but it does not help.

This is after running app for about an hour. Memory used keep increasing.

That's an important bug then, but I don't have any idea what could be the reason. It looks like an infinite loop, maybe we could have more info starting the app in silly or verbose log mode, and looking the logs.

Following are the logs when I run sails app with --silly and pm2 cluster mode. There has been some extra logging which might be the root cause. Can anyone please have a look at it.
sailsApp-out.0.log
"""""""""
verbose: Setting Node environment...
verbose: moduleloader hook loaded successfully.
verbose: Loading app config...
verbose: userconfig hook loaded successfully.
verbose: Exposing global variables... (you can disable this by modifying the properties in sails.config.globals)
verbose: Loading user hooks...
verbose: userhooks hook loaded successfully.
silly: Configured view engine, ejs
silly: Loading hook: logger
silly: Loading hook: request
silly: Loading hook: orm
silly: Loading hook: views
silly: Loading hook: blueprints
silly: Loading hook: responses
verbose: Loading runtime custom response definitions...
silly: Loading hook: controllers
silly: Loading hook: sockets
silly: Loading hook: pubsub
silly: Loading hook: policies
silly: Loading hook: services
verbose: Loading app services...
silly: Loading hook: csrf
silly: Loading hook: cors
silly: Loading hook: i18n
silly: Loading hook: session
silly: Loading hook: http
verbose: logger hook loaded successfully.
verbose: request hook loaded successfully.
verbose: Loading the app's models and adapters...
verbose: Loading app models...
verbose: Loading app adapters...
silly: Building action for view:  403
silly: Building action for view:  404
silly: Building action for view:  500
silly: Building action for view:  homepage
silly: Building action for view:  layout
verbose: Loading blueprint middleware...
verbose: blueprints hook loaded successfully.
verbose: responses hook loaded successfully.
verbose: controllers hook loaded successfully.
verbose: Loading policy modules from app...
verbose: Finished loading policy middleware logic.
verbose: policies hook loaded successfully.
verbose: services hook loaded successfully.
verbose: csrf hook loaded successfully.
verbose: cors hook loaded successfully.
verbose: i18n hook loaded successfully.
verbose: session hook loaded successfully.
verbose: http hook loaded successfully.
verbose: Overriding ejs engine config with ejslocals to implement layout support...
verbose: Preparing socket.io...
verbose: sockets hook loaded successfully.
verbose: views hook loaded successfully.
verbose: Setting default Express view engine to ejs...
verbose: Starting ORM...
verbose: orm hook loaded successfully.
verbose: pubsub hook loaded successfully.
verbose: Built-in hooks are ready.
verbose: Instantiating registry...
verbose: Loading router...
silly: Binding route ::  all /* (REQUEST HOOK: addMixins)
silly: Binding route ::  all /* (RESPONSES HOOK: addResponseMethods)
silly: Binding route ::  all /* (I18N HOOK: addLocalizationMethod)
silly: Binding route ::  all /* (VIEWS HOOK: addResViewMethod)
verbose: Policy-controller bindings complete!
silly: Binding route ::   /* (CSRF HOOK: CSRF)
silly: Binding route ::  all /* (CORS HOOK: clearHeaders)
silly: Binding route ::   /csrfToken (CORS HOOK: sendHeaders)
silly: Binding route ::  options /csrftoken (CORS HOOK: preflight)
silly: Binding route ::   /csrfToken (FUNCTION: csrfToken)
silly: Binding route ::   / (FUNCTION: rememberViewId)
silly: Binding route ::   / (FUNCTION: serveView)
silly: Binding route ::  get /getcookie (SOCKETS HOOK)
silly: Binding route ::  get /csrfToken (FUNCTION: csrfToken)
verbose: All hooks were loaded successfully.
verbose: Starting app at /home/shumailarshad/nodeProjects/sailsApp...
verbose: Running the setup logic in sails.config.bootstrap(cb)...
info:
info:                .-..-.
info:
info:    Sails              <|    .-..-.
info:    v0.12.0-rc3         |
info:                       /|.
info:                      / ||
info:                    ,'  |'
info:                 .-'.-==|/--'
info:                 `--'-------'
info:    ---------------_
info:  ----------------
info:
info: Server lifted in `/home/shumailarshad/nodeProjects/sailsApp`
info: To see your app, visit http://localhost:1337
info: To shut down Sails, press  + C at any time.

verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AtUAU7KVTXHSmFFNdpXU1hBAEcoS_DAjt.A%2FO91d3L2bcP2UNEVLya4mHvZkfzR5BrNl96CxIjUYsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Aj8uL6A3dddjggkakIYr1ep3cF7y8xT_t.uP9syaNPMiQjI33hNNiKuNP9XM8Hkpsg1CriYoSC7Qgand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AjeC-ps0Uf7HcBfie6rRFilDTGJUQhgfm.dMkoe%2FZe2NqJEvuqT0APaGDcS1xQF8QBbuw9xSjeVsMand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Afn2dDhcvQQU2OFK3AlULSSrdED0shTzc.5Wumr9U%2FuHqT2uLj%2BvGHL1A1sEQdMjccFDcV5ASoeCYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AAzaIOzNsmtX_HELkLBMuVVOY5Zy9cKAL.YoFBwtM8vMcsGFUZmIgR1EshD%2F0ngi2TXmWOIoTYGf8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AO5PYMyChw_96GfdnLud8zqCxUQUMEKlo.EuFxR2S4rYATvBz1YMTOepS2zVb%2FRlRZvXQ8BM6ehIIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AS20PN1ZXa9rLwMeIVWO9T_UzJiWmQxzC.oQAI0WkZGmDRLTdbEiF0LSy7Y5c63dByO2Gu4tz3HyIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AY96BCojU-dSGC-ShfgCchN6GotJRpMMN.DDjsJuewk%2F3wphMWr%2BXZSNGojAWazni8rkObJ3H6XmEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AK34XD8X9-KALTozEcAiLlX1bAJS3XKYN.2efaxf7k%2BoKRa8Jctm6msovRlu4UpBojFge3JpDxppgand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A6iRqClRvHTvSGJSqws0PTIIi12Ytz61y.66OcVMaftUQXZ8cHbLapxlFdTQWOgRX5XRbDXnWOpMIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A480J2ltKoH2ZoSIkCRRPAlJkLhlWUbjT.GHPJ1Fd7wk%2Bcs%2BQih0xUl3%2BQjo5TJjSALaFalBmCcDUand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Abs0T9ufBzSoCBxskqmSrjO7NbGp1yNRD.xzMhkEyRK%2BhXw%2B%2FRazxMu34RvccdlerIyCzgUzuFAlIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AZctbdI-h445ypphMSYdQtoyVlSXM6EMj.RILnm7rbigZtQmOS2C6U6g%2FzNfPmhT2J3hE9NcnUaloand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AObwLojipMMkVR_Rhq6UKZ1FFX69wjYg2.oXhHpDPaHCEC0mBS32nrEJGIv9itMUF63%2BgFxKm56aoand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AYMh4D1GOEMb_qZzLnT3FHZ4D3kfOnq16.OZBhh5bMd70fhDweO0mdDsbQkwZ%2F%2FtkzQcTCD%2FAm0sYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A43a7-9nXkLX0zrKfKP2_Q0UM59_ap3SE.e1WxKOKMuVLTZMTN5BRyuJnp5hiWNGikVoNZO1rS%2B9Iand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Az2DQqn4WvQORCiz3yFCJ_KHl1SA_8uXL.cnkHIxd9YHaYF8yYQgzXYmvErHGfn1w%2FkLC3H05FPZ0and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A6yhJH1h0VarLnEPK17UfzJGORWz2Ou-C.HehodxKmOOCTOwfKiYjWo1yu%2B%2BrvbxS%2BS6P%2Bss1CLM8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AOY-uTrrkcIJTYBLDqeadacz0wX1Dv7AW.6b8AeAX8WsFp4%2BPtooEznC2UdZ%2FpG%2FgD5NoEvfzIveEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Arx9RZV8FL920e0YRIatReTXQndOJzi-h.Y9K3Ue0Gz4oWQ2DOxelO9JlTHPbfNjZblQsR9MsZFSUand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Aum1dh-cC8Lyzke-FBou59Pu6JgfuN-hb.2b6Bgcj%2FFpM1jNVU%2BM9s%2BwcTlRBUsNZZYF6HydsnOaEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Aoxj17kWAclVb3iz47cVIecfuQc9pfggY.WyeKVvxA4mG9ILepbIeiowcQGRJBj%2FJ8HLEZPY5zVJgand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AZ28Hb0s1_4B-NeeIdPZohC1c5cSrC3GL.XdMriENV54aMJ%2B65tCTreUW5459PB21ls6wNFcHGHHUand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ACu7cLQL7IQXPFdLpKS6euGyNOhSPJr2A.%2Bqxcl91mnopBhEK7%2BIvC4uRPDgr5OTaSjOnfTMgUyaoand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A30d2gOVGVWwr_ekUkkz6uWoTRc7te_M0.vH3OqBL9JmupuCcyVV3ILZPEVl0taRpjB76EWPZr%2Fa0and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ACVoAjxziSHO61hZ3iOYrzjr0tvIiQqyU.YBsYWxQVaBqxWoO24oLitopddT678%2BQZ%2Fz1qwAUu%2FtQand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AKjhH46qVuoWA4lzfaYsq3XH-1phjYWgH.FhsGI28CfAMVHKIFkHSZ0hQ3LS5%2FwrAOgU5TMGrQuAAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AXOG7wpUDtAXyp4ldq7KUXM1oZJXiKZNR.BAuvC4p98x3Ilh%2FN7710bUh8bCxWPpEXi%2BMRt6GXwDUand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Ap-uqTsl5h1ZYJCkk3IN_ehS5EasuCdYQ.7gmZDpf65z3vYsFG3jDdU6KchcDJUzQQT5Uq7G4iAl0and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A1Hxkd2xJ9Su4RM8ZgMvUaRyPkPR1efcd.RNkbgVjI7D5HClIadjEpUlCs%2B0A8jlc0SnAyByZbuuIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ADe83ZF1BspGMzMC88MCX_i7ChiCTru6t.2cWU0Oi1uxP%2BjhDO5GsouLyHJx8JH2htGWTGsz9LULAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A2XZNSOphLni-oNWlJwyFqezKWGlyuMGC.yHnbJ3gXW%2BotMg8dRyi%2B5zQAJXtfIiOi08cEkqocmnsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AWYv3743QN1uJrFnxkL1pAtUV1jC6qCzk.EYT6UH7F0SDFkKLvlW3IaOYYBCIbDS2v8rMSbP%2Fe0wsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A8NFcdw9sitCCecy_gp3IFYw3p04lsYuq.JBjDD2h9Yig0s166kPBtfBgJeliQ9VmWkkqFpzyuPNgand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AvMeh68adEojg4yZFwUBSor3GqXS2KawL.zNCenKb9DcFUwOoT2zid2JO%2FA32qIn%2BbswYVJM2tqy8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AXOZdDFXPiJo15PrR3whu1xtIaMtypQbv.S0u69QJI71%2B1lwbS4A%2FHRTVQhenocsZK3UxaUw5f0I4and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ABSV1ATNlg59aZnMFDQYurkiVhnMvT_Za.YgXXZdd25kVlOmV1aOcmcZpRXFl5hRUIOPvDwD5lPTIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Af1G89NmL06ALeKoBOD2Fk-YvJOUntsqL.vEKnS9P2WS2zs57c6%2Frm5B%2B8c1fQs47dsjrYaeMmzkcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AJZSvB6qMNugHw1xNFCoHC1ovnNaH25j_.4hmZid7TErVsE5DT55IDgwvvusBg7x0HYGLdK01XmrYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AxGbZe9KuY90Q_l4U1drzSwmrxHKAjohi.udCw4pGmIanGwAqaqhlWU953%2F2ntXuaOKomlvy7aE5Yand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AIGsfXzG3-L88TCvESgQ-1VOOOrejmFWy.oe037HKzQoDeMb7c%2F37QQwnBc2oQShlW4Je3W5ZWddwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A-4y8ko9o2FG5i0AUbmCAkOG8zLvrfnP4.YrWF%2F0OCvsExT3HfMtYDlcrmIP%2B4PqtrczLLheXBvzYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AFFq_oO9shmDuksSbXgVqT1IQwgHoCiwm.o6nG8SaRSmTCWidhHIuT7p1mhPLUSr4v%2FwnqtuzzLcsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ALqlefEVnSABxv6jDSutGfHRABtl2pX8w.MzWfbaRqZzy8pTQzvT6GlfvPtYnF4rGNEAfX6AONWZYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ASsvAMp2jMCJJVNGimOsF1MxZ2g5N-GI7.OLDENtHv8tFaEHU9SLmNxElaeXxmAF8D9AjbP6b1eycand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ATR0m2dd44z8LqAbNh669gABmDobn0vk6.2u6WseuZTuEr%2FLxGXrdwmH1Q8y%2BVuwiYrdzTcAvyk%2BUand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ABypqPJIdjgSTbqnCTpXi3YqUPy0YV6gD.J1ywCv8oN1rjQUGrEp83gWEeW8gHSnoagL0iXtFH4uwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A7B38zVoxdEhN7lpQT2pnwSIugcRmpaqb.MR%2BZievko0ybnDWKtkt8pHkH0KgChvPu7PmZAyk6SX4and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Af2NdpNiFz8b9XYvPdgAWX8dcon3BJzBS.3JDE1S62kCsBojj4mKd5mkcFZjDEGI4BHckdgvHss3Iand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AlxSEElAcmJ12eByJrsuMWUfIG0MiIBH2.WPnThlSdvvYEBtI%2BnSlnxzm%2BehKHFBpRPOSOplUYxRsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AhIBXBkyhe6LiVXU39b34WGhjS61Qv--I.MtmvrGBPywTgwTRLZT4BsACje%2BANycHTlG%2BkMFtbbBgand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ADDUIVCl2iKltme83QEdH7xN4MJ3T2v7O.BDgfeBt2llKo2ox1y5UnngO0aV3xNmgkuYKurskEhbMand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A5EIaTIB9tHtO-4mIaVcepV7hh-PyWllO.TrofGYC9a2%2BagSuSZ6%2F%2BLfzibDg4smUpSf7vfA%2FAjLwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A3gDEBWC1iE51W9EAUCN19SeX01YNhdSH.s6w4%2BWVhgxaoRSRdblfaK9KWkivxOq7L1CaiZ3C2nuYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AklkZ3Mb1BEC0BLFItuKQNPfyu56LtSPu.rLmDxy7bxZ78hFoYM8pCjOTwhx2VfTKwIR9ZNOismyIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A1kIqvOxO8amZxpGLn0VUABNaQQbL-8YK.opfIFpXaoPgMHKGOSzvSFMS6LQ4MutC7NuFw8XBhLRcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A_ftGg0WzKOsAQAyq2LXqnkrCkgVfBO16.y24bSG58jOwqjig55%2FhwT3sO73tL5QHQz4NoqFLfF%2FQand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AsdpfkYC1V3ofe4oHypNVN0kW0JcGzORD.08ZVwT9HJHX2UqUEcwN9ZptIs%2ByUuVRInvmaBeysGWcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AHP99jHkyH3ZDHOFwDogS9BggYCiM-aF1.%2Fe97lpuDw6WN%2BwhBT9d5Sno5qt%2BfjgHfhi2s8D1anNYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AX2ALCZs05F6okbAGemep0bTCZ1-IGK6g.NWu%2FfkFZ1fyAbxY1DOp6ORbKFMsDUSeeBLH6T48%2Fk5Mand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A2U6aEaXNTmi18SX-h5g96xt4ua8QPacN.qLznullVILfbKzjezYXvGV%2FlflDCG27Y0H8kxX2ylS4and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AOapNc6F6hKH3cAYHObmV_akvsVYXjOP7.eFgGTtAM%2BgUvHGbMdn4DBwWC4a6txNyeTzuvrGjF3kMand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AQDehYuQG8w0RMDMAB9jUYxOorc_-p4IQ.UbUwh78MRaRVpPCjtYYFWurFWoyvgdB6A9Piy8vW%2FZcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AKut_JnxJl_kqc4OulCzuk64x0hLUcvYg.EeX%2BiZyZYAj6SNYI22yeeEswR7nxw%2FHDiKnIXZc96Osand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AJAqG4Q4v11olpf1V1r2JW0jWUfGQAeht.3%2F9dOKSps6XklpUNOmRelMLI2OTce2L3REFSup9I8kEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ABu_J1p_23rWeJof9Jwdn7wsU6-EtGNlL.WKz1Qoo4NdlgRgGhlv2HednBtGaNGK7anebd4OeLNsYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ABPUgCjg_ln1EDKUbpDTeKjtiwiEozO9h.%2Bwq6iQyxBm4ezeyfkntJDKZ9mFheIebOGcAkGpZ02fgand saved it on the socket handshake.
""""""""""""""

""""""""""""""
sailsApp-out-1.log:
verbose: Setting Node environment...
verbose: moduleloader hook loaded successfully.
verbose: Loading app config...
verbose: userconfig hook loaded successfully.
verbose: Exposing global variables... (you can disable this by modifying the properties in sails.config.globals)
verbose: Loading user hooks...
verbose: userhooks hook loaded successfully.
silly: Configured view engine, ejs
silly: Loading hook: logger
silly: Loading hook: request
silly: Loading hook: orm
silly: Loading hook: views
silly: Loading hook: blueprints
silly: Loading hook: responses
verbose: Loading runtime custom response definitions...
silly: Loading hook: controllers
silly: Loading hook: sockets
silly: Loading hook: pubsub
silly: Loading hook: policies
silly: Loading hook: services
verbose: Loading app services...
silly: Loading hook: csrf
silly: Loading hook: cors
silly: Loading hook: i18n
silly: Loading hook: session
silly: Loading hook: http
verbose: logger hook loaded successfully.
verbose: request hook loaded successfully.
verbose: Loading the app's models and adapters...
verbose: Loading app models...
verbose: Loading app adapters...
silly: Building action for view:  403
silly: Building action for view:  404
silly: Building action for view:  500
silly: Building action for view:  homepage
silly: Building action for view:  layout
verbose: Loading blueprint middleware...
verbose: blueprints hook loaded successfully.
verbose: responses hook loaded successfully.
verbose: controllers hook loaded successfully.
verbose: Loading policy modules from app...
verbose: Finished loading policy middleware logic.
verbose: policies hook loaded successfully.
verbose: services hook loaded successfully.
verbose: csrf hook loaded successfully.
verbose: cors hook loaded successfully.
verbose: i18n hook loaded successfully.
verbose: session hook loaded successfully.
verbose: http hook loaded successfully.
verbose: Overriding ejs engine config with ejslocals to implement layout support...
verbose: Preparing socket.io...
verbose: sockets hook loaded successfully.
verbose: views hook loaded successfully.
verbose: Setting default Express view engine to ejs...
verbose: Starting ORM...
verbose: orm hook loaded successfully.
verbose: pubsub hook loaded successfully.
verbose: Built-in hooks are ready.
verbose: Instantiating registry...
verbose: Loading router...
silly: Binding route ::  all /* (REQUEST HOOK: addMixins)
silly: Binding route ::  all /* (RESPONSES HOOK: addResponseMethods)
silly: Binding route ::  all /* (I18N HOOK: addLocalizationMethod)
silly: Binding route ::  all /* (VIEWS HOOK: addResViewMethod)
verbose: Policy-controller bindings complete!
silly: Binding route ::   /* (CSRF HOOK: CSRF)
silly: Binding route ::  all /* (CORS HOOK: clearHeaders)
silly: Binding route ::   /csrfToken (CORS HOOK: sendHeaders)
silly: Binding route ::  options /csrftoken (CORS HOOK: preflight)
silly: Binding route ::   /csrfToken (FUNCTION: csrfToken)
silly: Binding route ::   / (FUNCTION: rememberViewId)
silly: Binding route ::   / (FUNCTION: serveView)
silly: Binding route ::  get /getcookie (SOCKETS HOOK)
silly: Binding route ::  get /csrfToken (FUNCTION: csrfToken)
verbose: All hooks were loaded successfully.
verbose: Starting app at /home/shumailarshad/nodeProjects/sailsApp...
verbose: Running the setup logic in sails.config.bootstrap(cb)...
info:
info:                .-..-.
info:
info:    Sails              <|    .-..-.
info:    v0.12.0-rc3         |
info:                       /|.
info:                      / ||
info:                    ,'  |'
info:                 .-'.-==|/--'
info:                 `--'-------'
info:    ---------------_
info:  ----------------
info:
info: Server lifted in `/home/shumailarshad/nodeProjects/sailsApp`
info: To see your app, visit http://localhost:1337
info: To shut down Sails, press  + C at any time.

verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AhZ37GCPEKTcQX_yWauJWIZdT-6ifP4-K.BV5Ae2aYePNF3xYWFyETAGYaQQDlOhG8%2BYLW0y7tfwQand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AfUrwmeyu-0OQwxytJfZFDhXLOZ4dJOzE.krmwG1mMKkj9Bwb90QyQJc%2FkNqhuKMJI3UHZaEuwdh8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AzYFy363qGzLWc2VQvySDuRLCD__V0zpn.fkaSgJYvhBEIQuoZy%2F4ToP6bKK19qu%2BWA8Xnvzm8lN4and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AjF2Ze-C0DmsfyO2hhtEdMcxbkXhsFyIS.yJInQlHK7%2BF41uITREYvit1hPzr06ec3F%2B5SbrgCb9Aand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AZU9rzFtEXRWsrLbwYaee3EWc9tEF2Im6.gjpwkm0ZlQFOkPeIWIj9FKbUJiFDM49US3ik5AWSa%2FAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Aj8UdVt6AHvI0jpX9DlWhpiaX92OQMjWb.4Yj84BLGEEDZX6s2rJPAPonrSS3oEZJvVjNCG8mmUAQand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ASAzs_qT5PfjP7RtGoNgqrfU_XgcydP83.wHFf7UjlpWCjJ15SWUWtZcy4l5cGFPZZqqilIWtAZkAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AKHHo1Enn4onO_7qfRuHwLmsDWiJ0WMiv.tSB9cTsHLjIWZHrIFz8O%2BKaVqPrRXhI7zGv%2FVczLhVYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AFPgAh-MNQ76aPJDHUQWSC4fHSpCinmLY.StVVvZws10ZqENtI%2B0c0AuWXS2ffSWwjsAuo1gtpF6wand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AFBinFCx9ya1jDXisjZPmOll13lqTyvzR.w4OXfM4I8QhyEtU4bOpbWT4onqGEQ2jSVBmtSln2fyQand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AHiLljk8Zsbnm7yaGhv56cDiewUm2xPlw.Ltv5lZaQF9PkQlVntVpW%2FRiiAlw5cf9ThCqK6hBLxxcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Ad4v6QvLdmn8lEGwr15L5GLCBD5rivA3R.60SaTzRGAO%2BgUVofNDhP9ooWydEs%2B9ZnaMSaGrUVKvYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AVQ6sBWw1DkeYBa6QSLnjuwgmT7Mr0DvA.Cp9tWwzp0PQW6X0kRsyye%2BDLmytzG9Yd0Pk92KryhlAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AT9A8PptHbctGPDLvWBLbZirhXvntLIVV.K4a6FQmbnWZSGg9yVP%2BUySxoZQL8re1n%2B9f5RzbnUcIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AfmxzoP1oHneGVrnJTuye0XV6VN4X1T2u.N%2FbGPeVnXZx%2F1iGpVGAhwdLR3bVV9sGj216GXq9WxYsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AhnomcZo6T7uyiWhiffygjnKXpWsaSpSf.2UNyLdKG5tCtfu1AKKI8KO%2Bysxc8OdZP75O22KFgvAAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A5qOFtjjgTmHX5_Wb1dMxt3K4T6B4h6Bp.tPb3hCjfn0bJBlu9QBMePM4yv3%2B%2Ba99E1Sl6lako3sEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AI1gxjwWmKl7DGyrfQWR7NEFsfRk6Uykx.0HnFRgNIM29Hkq8wKBw8DDK4lS5YfZkmOGToAYtmJAMand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A3ea0izghswg3440O_z0Ftlm6tIAugvOY.DMT4WkV1ehpFG4oCAlJjvOzb3EMaujy%2Fhg934KFRqcAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AFrBmdob6CrkjHsKokDBeFcBZ-T-AJ3Qp.%2FrECZZZ%2BxAmJ9qEhSKafF6jldBwjbgz5dryayuZTdxQand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ANYIvkTeHTS_j4W_3qhsgwsvotv9IwRNE.LexTcyjj2K%2FNPEfDqQrFTItjDjjgtyhryU8sx2UI0Lwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AhRKZOKkH5ujdwBZ1Jpt0MdQKCvdEe7h1.MqBHi9wH%2BvTVmQgkdh7U3rJRLrdoTFkGEZxXkM%2Bn52gand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AyLXmn7AfY_ftWBGOeN2NaiSAm2UZiP_a.gUtSQTOLh60H4nLZeV9r3qGr8UPdnrX7UGT9OdFroc4and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AiE-WvZ6OuKV-nRcA1fyenJjG2Su0z5b_.CuPss4RbHHsYHpyPD%2Bm4SG3WF1NcR8ttHyUBYT2zjHcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A5V2GEiKFSrKb9dIjcjB1L0_a7ivSa7_m.Ax%2FHD2n5E9B8GX%2F%2Fyr73pO1JtcX6rmZib%2FkgAyP7D%2Bwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Agez8zk6gTD_vnTaVPmwyz5vXDgyliSF3.vw7l40XS2zCh9LZMA7Q01EjKRDHDTl6BoWvBW4%2FMuAMand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AeAm3Y9tpOogSqdN8dWKdY3ro7hZCbkPS.DCF%2BEKsOV4x6tpIP83OmwnQ%2F9SPjN17KJ6qFbQLp5LIand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ADTItUkUD2YggdhRF-n9ufnqYZMHH6dxO.gDFuk9UPuhCS6Fhf7yj1kE2BjtXFgPB4aipouAcQ%2BB8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AnMTgzYEnWHHud79tjHAIAjmfdsLOETd6.F%2FxN14Dj7l77uEmwiw5khwc7B1kmfO5hyozS1S5gxdwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AmNphWZNmzukDwgbjemi-m1wYi-HOkdhe.ODjeQvemLiHq9GqCgrV64FwkrKB9H3RGyhOVoOag9Skand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AicaaPE5bmTSzrXSo1URNe8mUhqaRkMfa.fL%2FnKPR9icK0RiW4rTZtlT%2FAsgGjgfn3gvoCWns2VzYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A1vX9h4YZhQcGeudTBA1l6Q3Fc3s63WmJ.8ju79YOQ%2B62cnHoV19C9LWwtgvHN2USC%2FThveyVHSDAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3APxEJZNoqvdunlMEnEPM911kmz-jFfnFE.c7MjBeVnyevoJKHPw0O7hwtlsZ3X7gOLc3ugaOQg1Ggand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Af0_Wk-6pCG9jZEFd_BYeKwyeHj35t9Je.6JXW2qJkeyhA8zejlDyLqpvp4LJw6a5LLxy0IBCViFEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Ahf0lsOwiaxRKAxRWSUfFJU_kssf3W_Zx.ZWLZDt%2BSAX7wiwhaaYEE7lq5YPvnvVmoHJZ6iA0bQIcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AlpYl0CyuP_jRcME_G_iR1HhaQYjpNcmI.wnGTKMfF77Ys13zYa1b4SGM%2BpXBtqwdqTYvAYlUgIUQand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Ab9Qu5zTfbRFF0BoELhyQTfsZKk1-TCHV.ZKYc%2BpCy0%2BztPmEFlkQyWnaYn5OTvrOzaEpGL0LPXPcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Arhuyrd2UdG9xDdUDSNVQE1vRIn_ROnte.5%2FbaymCmTY6Z%2BILN6a7TBxPsK9eXCGqcMdutEN1sNtsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AQGbDhtFzY1aHjboic-gU9vrOCxJlC5bc.s%2F%2BQCgjrRFcDpR%2BzJwseWhZd3IzJJvJaBpFU7bt0o5cand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AMm8IHZV3XNmbVRjz9IkNBFcKPhE8NL3Q.XE9vB1YdlQvTq1o%2Fkx1O2NR5Wy%2F64tTMJyk145u7UPsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ACIWOii2VE9WNhwKnDwjGCIZKqOcZKPnH.1PtxFTyK%2Bqo7W5TgfzamAKev5bTylNTsZ%2BJP%2FBBwrPwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A073Jc1H5OM8jcEi_oXVPJJeG1wToSww3.VncW3XypEqXlg4NCiHB8scrUxXNw49ldXs8kTmd6smwand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A9Yl84f7lJ56FbAOnpTtmf7WehW68Bo5s.tzQkb0Z1GSTj7wFYHqOQS5g3noEchoWM18xtQFCo6R8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AbcmM1HG-O6k1GKCMKDm-NDbKH_9eB079.7cvY80etE5KJR0QO3QpTR4qerkDdA%2FoV9AAY%2F9Q4%2FmAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Aq7gytl04ebl43JLysDxyQy-OaoNssBgm.9e31Tm92JUOo1p%2B3tNqagf35CKR7R4g54CmxVn4d%2Bfsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Aux9WObaT44dpaQt2ebYuadvGXbt2RC5F.Lakm3SG4rgnFpJYY3sczJkmU%2B78r%2BSUHrO2HHMfSBsEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A9GrG4su9ECrwcMT4G4HWYPxe8McjQ5J_.1xo5bgHRZ03MzMm37Rv5Ry6FRh88EZtE9kFhaw%2FX7VMand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AazmqQVGKrZGrULOCu4mMENZuJUyzWsv8.ZqFsbZHy5ewVWzZCNgN04sYRSrpg9kVdemVTxl0ziBUand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AWuKnSg4tU_L2KLH7vhSRWDBvdtdAQT3b.ZUNBCek0yT30Ckji1BY2hRv467GggmQFm0t1xdGZgFYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AcHA1b7P27KOScTQdxzpVvco_9UJS_lHZ.Qeo1nYu5W%2FejEqxfnpjRWq0xVHaNcV1vtBm496APUYEand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3At6ReJd7hrGEryp63o8uCa81_ta7VkPAK.WDcS0SrMzOvK2c9WUUG1nu0L3qv2elUZQm%2B5oVx7pp0and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AYUPAF9VVetvTutxXeJFl-OFRtgYGWqwz.KPLH%2BFov%2BhHzIxpbKJI012o4zSeTjsUSUoI8rWshUrYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A7zPgGObaYBV8NlqPFlMM73WnYVSoxt7p.aF5n0mei6rXzVhjZOe66l9wbDo0V9uiiKG%2Fue9TeD1Qand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AYf2Qo8Y7aeVtFNwyONcsrhXaLn9rcZcT.zchfBPFEL3nUPy8VJEPglr2vELEY%2BJXXSo8wEBWHM2Iand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AXlhE8068-tdavgVMNKwyUOxMCzjXk28W.n1JGzcPk%2B%2F%2F58vbXR%2BtOF1r8xF6Q9oTXcrhM3k3wgqkand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A88k2NIBBexvPzprBoJhK0QshgIZwS9dj.PL8r4NWp6XaimVcHIlvUaBhihdLHhot%2F8SrIUY3cov0and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AIjVB2Dowibo9lp_9_TbgdDtwUThdwiux.i44%2FoYdSebtmKzw6jTDaeM7AfMNqp2J07vTsFtJJNUoand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AjALO0-FmOnHKZzMuLHXxL8GNw5cDDjXN.YBEGEPqAYmrDUZpU%2BcBCmL%2BH3GSIZ%2Bw6%2BoQAibrz204and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AH1rMRCrZa0XfXvaXbUpQsxOTrq2ck4rq.jvmRcFOa7fGfFxZrsda1yaGHOgJ%2FEgPoILu0NGm2Q%2Fgand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AcYo1AJEq-kZwKyH7XGPSg3owAT6qTm_1.7fEEXkXVRCrs5Io9JhyYv%2FKtxPlsTLuQsE7dwqdyCXoand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Au1H1z6GLDg-L00x7NMJT9x4aY8ZQ-Kqd.2WclGGKKEDzuj63oQNLyL9y1iNWYL3xoImLbFk%2FB9P0and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AR0a4xM6FFNZIFjtROoslm8V8q9Q8HaGB.HAM4Qk%2FEkjm0b%2BPWdOVNfGg3x3A2L4GxOwHK2UjrpW8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3An9sgXLqEaFcrttp2RWOhLGh58dvEoaWF.V%2BO21sa9CcRSaftZfGnFLZNYww4J3cPaWuUN%2B0m976Aand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AJdJYDoD9Kk7Cuhb2ZOHC0-lTSSnb2j9O.UHTiz28eimVfrH%2FVhbKPHcEAipBW5m%2F1qU%2FzFlJfI4Aand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AxCAbzod5m6hsio5sCPlpkL2ulJHjwFGb.AwwMb%2FTPDmUdoJvjhR2%2FDf3T%2FopDeHDvlzD6sYZ0vREand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AveUAm2K_P5zDwgiKyYl6YUZmO6bHRyD7.JvqBdkYmUQLPB98NasNRuXvFMEE9euRojzWIobW%2Fm6Eand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AKylfVp7NqkGJIsKnTKhGrqIUMiGWtGra.PNEnszZWbK14NXxRv%2BRjLdWtjFvBlzIw5Knh%2FLkSfY4and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ASBk-SBewM_bXdygiKTUgmAnDDu4kd6V3.YortZnOrs7z9edaL3VdXswqaivR5SWam%2FT4XqwpRfJkand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3Azg3VyUL8Kc3TYLtaaM5IgzKGtZnYcHBL.TgIfh2q4RM8WpgrMlSQ5rEYo0ages0Sumqx%2BakyYDRkand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AMReivWvKHaqa__FvByDXHQwxWqAyOKzG.5f3gfkpH1kr68gRdwIbgi4aVf8l00mXsLVpeTGb%2F7NAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AVHTSE4nD9RjqzAMfY9U3isOhuWvmMddd.ZxIQDQuoR51oJ5YA5WlKCLIxejrPjgV97PQgKri0sFcand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ASPSOWUUEJG8VXtbQxMWQreUhwImWdEC4.xDNUWS5LQKfK9KaAxDzQBI7nVLImhozXQCzT4Lzxmrsand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3ApeZZUZl7wDQp13gbvQutVaTu9TI1sndq.6bXppB1LGyMWjfZzAL2pJ56NLrQT%2B936SorSdRLovtUand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A_W7JvW0H_EtBRQDECW79V77sBNyDCJ1N.m3QsFeO7aszWRFfGapwxr6pD1VPZYvAlcotvnkj2JSMand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A_C9DnyNwqh2u2vdgiiXQlfsHj3rGoUz1.IJMunZPoUR5H6TaHV20MpMQRiZ%2FIPx4qGqgxghH6NNYand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AEabuOfr9GjaFkJKA-iGw_m_LBcmA90wG.MPlVVv6udntO%2F1vEaQJOtkeRr0XJLubeFPU6X0AfVeAand saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3AbGXDpoRpewHKnCAUf03N7adshB4HwWo0.KW9KJnO3yQuEELgrLgNeB4C6AoGwwyk1QT9aKcyg9c8and saved it on the socket handshake.
This will start this socket off with an empty session, i.e. (req.session === {})
That "anonymous" section will only last until the socket is disconnected unless you persist the session id in your database,
or by setting the set-cookie response header for an HTTP request that you know came from the same user (etc)
Alternatively, just make sure the socket sends a `cookie` header or query param when it initially connects.
verbose: Could not fetch session, since connecting socket has no cookie (is this a cross-origin socket?)
Generated a one-time-use cookie:sails.sid=s%3A4CP_cQ9tB_eN5nZnzRoqJcEh8tBFusDh.VyPD0AM%2FKm9OBC7AX6VctPI0VMwBK9ULKdsnNcxlKTQand saved it on the socket handshake.
"""""""""""""

Looks like something is opening a websocket connection over and over. Wondering if:
a) a websocket client is attempting to connect; or
b) PM2 is trying to connect for some reason (less likely); or
c) Sails/Socket.io is interpreting the cluster connections as websocket connections (is this even possible?)
You said you're not even hitting the app, so that should rule out a) above.
Given the high amount of socket connections, the memory usage is probably coming from using sails-memory as the default socket/session adapter, so all this data is being stuffed in RAM rather than a data store of some kind.
Anyone else have a hunch on what could be going on?

It seems like the sockets sessions are saving and saving all the time in a loop, don't know why. Try disabling the sockets this time and check the memory (.sailsrc file again):
{
  "hooks": {
    "orm": false,
    "pubsub": false
  }
}

Right, after applying above change, it is stable.

Now, we need to know, how to fix this issue. Whats happening?

@shumailarshad do you have a browser window open, pointed at the http://localhost:1337?  The default sails.io.js library attempts to reconnect sockets after Sails is lowered and relifted, which would account for your logs.

@sgress454 but 4GB of data on empty sessions is too much for just a browser connecting and disconnecting for few hours... And that just happens in cluster mode, I can't figure what's going there.

Not sure if this is the solution, but I found this thread over at PM2: https://github.com/Unitech/pm2/issues/81
Using the memory adapter for socket sessions when clustered could cause issues, since your session would exist in memory of one process but not the others. Obviously you'd want to use a data store like Redis to solve this, but in @shumailarshad's case, he hasn't gotten far enough to play around with sockets and may not even want them yet.
He did say that he wasn't even hitting the URL, so if that's true then sails.io.js file should not even be running and trying to connect. 4GB is still insane, though, but I wanted to mention the above issue in case that has something to do with it.

Actually, Sails apps using the latest version of sails-hook-sockets do make their own socket connection on the backend, so that in a clustered situation all of the Sails apps in the cluster can communicate over a message bus (see https://github.com/balderdashy/sails/issues/3008#issuecomment-111640710).  So if the log only has one of those "Could not fetch session" messages per app in the cluster, that's expected.  Of course it still doesn't explain the memory leak (or its growth over time).

I've done a few tests with express, sails and a basic http server : https://github.com/soyuka/nodejs-http-memtest. Sails seems to be leaking :

@soyuka take a look here: https://github.com/balderdashy/sails/issues/2779 probably you have that memory increase because of the session storage, sails save it in the RAM. To fix it disable the sessions or just use an adaptor as redis-session.
That's not the problem, the problem is that the memory increases in the cluster mode + sockets/pub-sub hooks, that's the weird stuff.

@Josebaseba What are you meaning by session storage? Can you quote docs or some code please?
Anyway, I don't see why Sailsjs would require almost 1.6gb of ram only by spamming a single http route.

@soyuka take a look at this specific comment: https://github.com/balderdashy/sails/issues/2779#issuecomment-91488569

@Josebaseba I have read this comment but can't find docs on how I could disable sessions. I noticed the config/session but I don't want to use any adapter.

http://stackoverflow.com/questions/28015873/disable-some-built-in-functionality-in-sails-js/28017720#28017720 try this and then tell us your results. Thanks!

ok that's fine now:

but I find it weird.
Never mind, not the issue here, and I was just searching if it was a pm2 leak or not :).
Gl with this one!

@Josebaseba thanks for your help on this, definitely an important thing to keep in mind when doing stress tests!

@sgress454 maybe someone could document this?

@soyuka you can send a pull request adding the info here: https://github.com/balderdashy/sails-docs/blob/master/concepts/Deployment/FAQ.md#performance-benchmarks

Anybody know if pm2 does some sort of heartbeat or ping?  If so, that would account for the memory growth, as each ping would create a new session.

As far as I now it's just forking a cluster and catching exit events to restart.
@jshkurti thoughts?
For the record I had to change those two things to get rid of sessions:
//.sailsrc
"hooks": {
  "session": false
}
//config/http.js
module.exports.http = {
  middleware: {
    order: [
      'startRequestTimer',
      'cookieParser',
      // 'session',
     // etc.
    ],
  },
}

By heartbeat/ping you mean hitting http://localhost:1337 to check if it is online ?

@jshkurti right

Then no, there is no such thing.

Anybody know if pm2 does some sort of heartbeat or ping?

yes it does

Does anybody has a solution for this? I Have the same issiue with<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>(for session storage and socket storage<EMAIL_ADDRESS>cluser_mode
Memory usage increases a few kb every second without ever hitting the app.

@sgress454 I found the origin of the leak.
Look at this line in the sockets-hook: https://github.com/balderdashy/sails-hook-sockets/blob/master/lib/connect-sails-client.js#L30
When you lift sails with PM2 in the cluster mode the connection fails and reconnect_attemptand reconnecting events are triggered in a infinite loop:

  var socket = socketIOClient("http://localhost:" + app.config.port + "/sails", {multiplex: false});

  // These two events logs in a loop all the time, increasing the memory usage really fast...
  socket.on('reconnect_attempt', function(err){
    console.log('reconnect_attempt!', err);
  });

  socket.on('reconnecting', function(err){
    console.log('reconnecting!', err);
  });

Setting reconnection:false the memory leak stops, but that's not a solution.

  var socket = socketIOClient("http://localhost:" + app.config.port + "/sails", {multiplex: false, reconnection:false});

@Josebaseba thanks!  Even with those events being continuously triggered, there shouldn't be a memory leak, but this is a huge help.

@sgress454 yes, I guess that the memory leak happens when it tries to reconnect over and over again.
For more detail, the error log:
{ [Error: xhr post error] type: 'TransportError', description: 400 }

Ah, I see.  I'm able to reproduce the memory leak, but only when I have the transports list in config/sockets.js locked to just "websocket".  This is something we suggest in the scaling doc to deal with environments that don't implement sticky sessions.  The solution is just to make sure that when the "admin socket" is connecting, it uses the same transports config as the app does.
Try that patch on for size--it stops the connection errors and plugs the leak for me.
Now, it still doesn't address why the connection errors result in a memory leak, but, one thing at a time!

PM2 doesn't support (yet) sticky-sessions: https://github.com/Unitech/pm2/issues/389, like Heroku. So to avoid the memory leak, caused by the failed connection loop, we have to set the transports to 'websocket', plus socket.io-redis. Check the docs for more detail: http://sailsjs.org/documentation/concepts/deployment/scaling

That's my conclusion to this issue, if I'm wrong please correct me!

@Josebaseba The patch I made to sails-hook-sockets should fix the issue with failed connections (and thus plug the memory leak) regardless of the transport settings in your Sails app.  The bigger picture is that because PM2 doesn't support sticky sessions, your app won't work as expected without setting transports to websocket, as described in the scaling doc.  That's the reason to update the transports setting.
If something else were to cause a problem with the socket connection, we'd still see this problem, so it's still worth looking into why the connection retries spawn a memory leak.  It may still have something to do with sessions being created, although on my test app I was using MongoDb as the session store, and I was still seeing memory growth.

I am experiencing a memory leak on my production application, and my application does use websockets.
Can this in theory be the root cause of my memory leak?
I know I'm not providing much information, please let me know what else I can provide.

Are you using redis for sockets and sessions? You have to use them or the sessions will be saved in your memory. If you are using PM2 remember disabling the 'polling' option in transports, and leaving only 'websocket' option.
With that configuration you won't have any problem.

I do use Redis for sessions however not for Sockets. Should I enable Redis for sockets as well?
Also I am not using PM2. Thanks

I have two Sails Apps in production, both running in cluster mode with PM2 and both using the mongo adapter for session storage, not sails-mongo because as far as I'm aware sails-mongo doesn't work for session storage.
One of the apps is causing the memory leak issue, I'm seeing lots of requests to /socket.io and failing. I don't use sockets though and have them disabled on both apps both I only see this issue on one of them which is very strange. The app I'm seeing it on was upgraded from Sails v0.10.5 where as the one that doesn't have the problem was a fresh install of v0.11. I've just upgraded connect-mongo as that was the only difference I could see between the two apps but that hasn't made a difference.
I don't understand why I'm still seeing requests to /socket.io when I have disabled sockets in my .sailsrc
"hooks": {
  "sockets": false,
  "pubsub": false
},

Is there anything else I should be checking?

@gilesbutler The requests are probably coming from clients who still have the sails.io.js script included in their HTML.  If you disable sockets on the back end, you'll want to remove the connection logic on the front end as well!  By default this is included in your app's layout.ejs file via the Grunt task, so you can fix the issue by just removing the sails.io.js file from your assets/js folder (or assets/js/dependencies, depending on the version), and/or removing its reference from the tasks/pipeline.js file that Grunt uses to determine which assets to automatically inject into your HTML.

@sgress454 thanks for that buddy, thought I'd got rid of sails.io.js but you were right, it was still in tasks/pipeline.js :+1:

Hi, in my case are having the same problem but if that need to use socket. Us for now happens in a single instance. Any idea to solve this temporarily?

I just realised that I didn't restart my app in cluster mode but only as a single instance. When I restart it using pm2 in cluster mode one of the processes calls /socket.io even with the sails.io.js removed and the hooks disabled, very strange behaviour.

We're running into the same issue after recently upgrading our Sails server. As part of this upgrade we've already made changes to accommodate for the suggestions above including:

Moving sockets into Redis versus memory.
Disabling the polling transport method in both config/sockets.js and the sails.io.js file.