docs: public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws ServletException, IOException
      {
          try
          {
              // invoke the wrapped filter
              if (_filterState == FILTER_STATE_AVAILABLE)
              {
              	nServicing.incrementAndGet();
              	try
              	{  
              	    if (request.isAsyncSupported()){
              	        //141092
              	        boolean isAsyncSupported = this._filterConfig.isAsyncSupported();
              	        if (!isAsyncSupported){
              	            WebContainerRequestState reqState = WebContainerRequestState.getInstance(true);
              	            if (reqState != null) {
              	                reqState.setAttribute("resourceNotSupportAsync", "filter[ "+ this._filterName +" ]");
              	            }
              	        }
              	        //141092
              	        ServletUtil.unwrapRequest(request).setAsyncSupported(isAsyncSupported);
              	    }
              	    
              	    // LIDB-3598: begin
              	    //_filterInstance.doFilter(request, response, chain);
              	    if(_eventSource != null && _eventSource.hasFilterInvocationListeners()){
              	        FilterInvocationEvent event = getFilterInvocationEvent(request);
              	        _eventSource.onFilterStartDoFilter(event);
              	        _filterInstance.doFilter(request, response, chain);
              	        _eventSource.onFilterFinishDoFilter(event);
              	    }
              	    else{
              	        _filterInstance.doFilter(request, response, chain);
              	    }
              	    // LIDB-3598: end
  
              	}
              	catch (ServletException se)
              	{
              		throw se;
              	}
              	catch (IOException ioe)    //174668 
                  {
                      throw ioe;
                  }                          //174668
              	catch (Throwable th)
              	{
              		throw th;
              	}
              	finally
              	{
              		nServicing.decrementAndGet();
              	}
              }
              else
              {
                  throw new ServletException(MessageFormat.format("Filter [{0}]: filter is unavailable.", new Object[] {_filterName}));
              }
          }
          catch (ServletException se)
          {
              if(_eventSource != null && _eventSource.hasFilterErrorListeners()){
                  FilterErrorEvent errorEvent = getFilterErrorEvent(se);
                  _eventSource.onFilterDoFilterError(errorEvent);
              }
              //start 140014
              if(_filterState != FILTER_STATE_DESTROYING && _filterState != FILTER_STATE_DESTROYED)
                  com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(se, "com.ibm.ws.webcontainer.filter.FilterInstanceWrapper.doFilter", "144", this);
              else if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
                  logger.logp(Level.FINE, CLASS_NAME, "doFilter", "Can not invoke filter because application is destroyed", se);
              //end 140014
              throw se;
          }
          catch (RuntimeException re){
              throw re;
          }
          catch (FileNotFoundException fnfe) {
              //same as throwable without traces
              if(_eventSource != null && _eventSource.hasFilterErrorListeners()){
                  FilterErrorEvent errorEvent = getFilterErrorEvent(fnfe);
                  _eventSource.onFilterDoFilterError(errorEvent);
              }
              throw new ServletException(fnfe);
          }
          catch (IOException ioe){                //174668            
              if((com.ibm.ws.webcontainer.osgi.WebContainer.getServletContainerSpecLevel() >= 31) 
                              && ioe.getMessage()!=null 
                              && ioe.getMessage().contains("SRVE0918E")){
                  throw ioe;
              }
              if(_eventSource != null && _eventSource.hasFilterErrorListeners()){
                  FilterErrorEvent errorEvent = getFilterErrorEvent(ioe);
                  _eventSource.onFilterDoFilterError(errorEvent);
              }
              
              com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(ioe, "com.ibm.ws.webcontainer.filter.FilterInstanceWrapper.doFilter", "260", this);
              
              if (com.ibm.ws.webcontainer.osgi.WebContainer.getServletContainerSpecLevel() >= 31 )
              {
                  if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
                      logger.logp(Level.FINE, CLASS_NAME, "doFilter", "rethrow IOE", ioe);
                  throw ioe;
              }
              else // to prevent regression for servlet 3.0..same as Throwable() below
              {
                  if (com.ibm.ejs.ras.TraceComponent.isAnyTracingEnabled() && logger.isLoggable(Level.FINE))
                      logger.logp(Level.FINE, CLASS_NAME, "doFilter", "wrap IOE with ServletException", ioe );
                  throw new ServletException(ioe);
              }
              
          }                               //174668
          catch (Throwable th)
          {
              logger.logp(Level.SEVERE, CLASS_NAME, "service", "uncaught.filter.exception", new Object[] {_filterName, th});
              if(_eventSource != null && _eventSource.hasFilterErrorListeners()){
                  FilterErrorEvent errorEvent = getFilterErrorEvent(th);
                  _eventSource.onFilterDoFilterError(errorEvent);
              }
              com.ibm.wsspi.webcontainer.util.FFDCWrapper.processException(th, "com.ibm.ws.webcontainer.filter.FilterInstanceWrapper.doFilter", "149", this);
              throw new ServletException(th);
          }
  
      }