Logout method is used only for auditing purpose

@param subject
Subject which needs to be logged out
774251
public void logout(Subject subject) {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
			SibTr.entry(tc, CLASS_NAME + "logout");
		}
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
			SibTr.exit(tc, CLASS_NAME + "logout");
		}
	}
965711
public function logout(Request $request, Response $response, TokenInterface $token)
    {
        // Remove host override
        if ($request->hasPreviousSession() && $request->getSession()->has(DomainConfiguration::OVERRIDE_HOST)) {
            $request->getSession()->remove(DomainConfiguration::OVERRIDE_HOST);
        }
    }
152089
@Override
    protected void onSessionClose(long sessionId, Map<Long, Object> responses) {
        removeInvocationRefUids(sessionId);

        if (owner != null && owner.sessionId() == sessionId) {
            ReleaseResult result = doRelease(owner.endpoint(), newUnsecureUUID(), lockCount);
            for (LockInvocationKey key : result.completedWaitKeys()) {
                responses.put(key.commitIndex(), result.ownership().getFence());
            }
        }
    }
64972
public function closeSubject(Subject $subject)
    {
        $this->om->startFlushSuite();
        $subject->setIsClosed(true);
        $this->om->persist($subject);
        $this->dispatch(new CloseSubjectEvent($subject));
        $this->om->endFlushSuite();
    }
1229841
@Override
    public void logout() throws ServletException {
        try {
            collaborator.preInvoke(componentMetaData);
            request.logout();
        } finally {
            collaborator.postInvoke();
        }
    }
121141
@Override
    public void setCredential(Subject subject) throws CredentialException {
        Set<WSPrincipal> principals = subject.getPrincipals(WSPrincipal.class);
        if (principals.isEmpty()) {
            return;
        }
        if (principals.size() != 1) {
            throw new CredentialException("Too many WSPrincipals in the subject");
        }
        WSPrincipal principal = principals.iterator().next();
        setCredential(subject, principal);
    }
206742
@Override
    public Subject performLogin(String jaasEntryName, CallbackHandler callbackHandler, Subject partialSubject) throws LoginException {
        LoginContext loginContext = null;
        loginContext = doLoginContext(jaasEntryName, callbackHandler, partialSubject);
        return (loginContext == null ? null : loginContext.getSubject());
    }
614500
public synchronized void logoutAllUsers(Context context) {
        getAuthInfoMap(context);
        for (String userId : mCurrentAccessInfo.keySet()) {
            BoxSession session = new BoxSession(context, userId);
            logout(session);
        }
        authStorage.clearAuthInfoMap(context);

    }
1127548
public void logout() {
        saveResumeToken(null);
        mDDPState = DDPSTATE.NotLoggedIn;
        mUserId = null;
        broadcastConnectionState(mDDPState);
    }
57771
public void doLogout( StaplerRequest req, StaplerResponse rsp ) throws IOException, ServletException {
        String user = getAuthentication().getName();
        securityRealm.doLogout(req, rsp);
        SecurityListener.fireLoggedOut(user);
    }
997709
def logout(self):
        """"""

        if not self.logged_in:
            raise RuntimeError("User is not logged in")
        if self.conn.connected:
            params = {"room": self.conn.room.room_id}
            resp = self.conn.make_api_call("logout", params)
            if not resp.get("success", False):
                raise RuntimeError(
                    f"Logout unsuccessful: "
                    f"{resp['error'].get('message') or resp['error']}"
                )
            self.conn.make_call("logout", params)
            self.conn.cookies.pop("session")
        self.logged_in = False
1189605
private void setUnauthenticatedSubjectIfNeeded() {
        if (LocationUtils.isServer()) {
            com.ibm.ws.security.context.SubjectManager sm = new com.ibm.ws.security.context.SubjectManager();
            Subject invokedSubject = sm.getInvocationSubject();
            if (invokedSubject == null) {
                Subject callerSubject = sm.getCallerSubject();
                if (callerSubject == null) {
                    // create the unauthenticated subject and set as the invocation subject
                    UnauthenticatedSubjectService unAuthenticationService = SecurityServices.getUnauthenticatedSubjectService();
                    if (unAuthenticationService != null) {
                        sm.setInvocationSubject(unAuthenticationService.getUnauthenticatedSubject());
                    }
                }
            }
        }
    }
204805
protected void setSubject(Subject subject) {
        Subject currentSubject = this.subject;
        if (!(currentSubject == null && subject == null)) {
            this.subject = subject;
            if (currentThread() == ioThread) {
                notifySubjectChanged(subject);
            }
            else {
                final Subject changedSubject = subject;
                ioExecutor.execute(new Runnable() {
                    @Override
                    public void run() {
                        notifySubjectChanged(changedSubject);
                    }
                });
            }
        }
    }
1011440
protected Subject login() {
		if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
			SibTr.entry(tc, CLASS_NAME + "login");
		}
		Subject subject = null;
		try {
			/*
			 * Only if we have the AuthenticationService running, we can do
			 * Authentication. If it is not present we cannot do any
			 * authentication and hence we have return null, which means
			 * authentication failed
			 */
			if (_authenticationService != null) {
				subject = _authenticationService.authenticate(MESSAGING_JASS_ENTRY_NAME,
						_authenticationData, _partialSubject);
			}
		} catch (AuthenticationException ae) {
			// No FFDC Required. We will throw exception if the subject is Null later
			if(TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
				SibTr.debug(tc, "EXCEPTION_OCCURED_DURING_AUTHENTICATION_MSE1001");
				SibTr.exception(tc, ae);
			}
		} finally {
			if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
				SibTr.exit(tc, CLASS_NAME + "login");
			}
		}
		return subject;
	}
443564
public void simpleLogout(HttpServletRequest req, HttpServletResponse res) {
        createSubjectAndPushItOnThreadAsNeeded(req, res);

        AuthenticationResult authResult = new AuthenticationResult(AuthResult.SUCCESS, subjectManager.getCallerSubject());
        authResult.setAuditCredType(req.getAuthType());
        authResult.setAuditOutcome(AuditEvent.OUTCOME_SUCCESS);
        Audit.audit(Audit.EventID.SECURITY_API_AUTHN_TERMINATE_01, req, authResult, Integer.valueOf(res.getStatus()));

	removeEntryFromAuthCacheForUser(req, res);
        invalidateSession(req);
        ssoCookieHelper.removeSSOCookieFromResponse(res);
        ssoCookieHelper.createLogoutCookies(req, res);
        subjectManager.clearSubjects();

    }
812019
public void removeSubject(String subject) {
        String prefix = normalizePrefix(subject);

        for (String suffix : getSuffixes(prefix).keySet()) {
            setItem(prefix + suffix, null);
        }
    }
581818
public function logout()
    {
        if (false === $this->isEnabled()) {
            throw new UserInactiveException();
        }

        $this->publish(
            new UserLoggedOut(
                $this->id,
                $this->email
            )
        );
    }