lib/jetty/org/eclipse/jetty/server/handler/StatisticsHandler.java

   1 //
   2 //  ========================================================================
   3 //  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
   4 //  ------------------------------------------------------------------------
   5 //  All rights reserved. This program and the accompanying materials
   6 //  are made available under the terms of the Eclipse Public License v1.0
   7 //  and Apache License v2.0 which accompanies this distribution.
   8 //
   9 //      The Eclipse Public License is available at
  10 //      http://www.eclipse.org/legal/epl-v10.html
  11 //
  12 //      The Apache License v2.0 is available at
  13 //      http://www.opensource.org/licenses/apache2.0.php
  14 //
  15 //  You may elect to redistribute this code under either of these licenses.
  16 //  ========================================================================
  17 //
  18
  19 package org.eclipse.jetty.server.handler;
  20
  21 import java.io.IOException;
  22 import java.util.concurrent.Future;
  23 import java.util.concurrent.TimeoutException;
  24 import java.util.concurrent.atomic.AtomicInteger;
  25 import java.util.concurrent.atomic.AtomicLong;
  26 import java.util.concurrent.atomic.AtomicReference;
  27
  28 import javax.servlet.AsyncEvent;
  29 import javax.servlet.AsyncListener;
  30 import javax.servlet.ServletException;
  31 import javax.servlet.http.HttpServletRequest;
  32 import javax.servlet.http.HttpServletResponse;
  33
  34 import org.eclipse.jetty.server.AsyncContextEvent;
  35 import org.eclipse.jetty.server.HttpChannelState;
  36 import org.eclipse.jetty.server.Request;
  37 import org.eclipse.jetty.server.Response;
  38 import org.eclipse.jetty.util.FutureCallback;
  39 import org.eclipse.jetty.util.annotation.ManagedAttribute;
  40 import org.eclipse.jetty.util.annotation.ManagedObject;
  41 import org.eclipse.jetty.util.annotation.ManagedOperation;
  42 import org.eclipse.jetty.util.component.Graceful;
  43 import org.eclipse.jetty.util.statistic.CounterStatistic;
  44 import org.eclipse.jetty.util.statistic.SampleStatistic;
  45
  46 @ManagedObject("Request Statistics Gathering")
  47 public class StatisticsHandler extends HandlerWrapper implements Graceful
  48 {
  49     private final AtomicLong _statsStartedAt = new AtomicLong();
  50
  51     private final CounterStatistic _requestStats = new CounterStatistic();
  52     private final SampleStatistic _requestTimeStats = new SampleStatistic();
  53     private final CounterStatistic _dispatchedStats = new CounterStatistic();
  54     private final SampleStatistic _dispatchedTimeStats = new SampleStatistic();
  55     private final CounterStatistic _asyncWaitStats = new CounterStatistic();
  56
  57     private final AtomicInteger _asyncDispatches = new AtomicInteger();
  58     private final AtomicInteger _expires = new AtomicInteger();
  59
  60     private final AtomicInteger _responses1xx = new AtomicInteger();
  61     private final AtomicInteger _responses2xx = new AtomicInteger();
  62     private final AtomicInteger _responses3xx = new AtomicInteger();
  63     private final AtomicInteger _responses4xx = new AtomicInteger();
  64     private final AtomicInteger _responses5xx = new AtomicInteger();
  65     private final AtomicLong _responsesTotalBytes = new AtomicLong();
  66
  67     private final AtomicReference<FutureCallback> _shutdown=new AtomicReference<>();
  68
  69     private final AsyncListener _onCompletion = new AsyncListener()
  70     {
  71         @Override
  72         public void onTimeout(AsyncEvent event) throws IOException
  73         {
  74             _expires.incrementAndGet();
  75         }
  76
  77         @Override
  78         public void onStartAsync(AsyncEvent event) throws IOException
  79         {
  80             event.getAsyncContext().addListener(this);
  81         }
  82
  83         @Override
  84         public void onError(AsyncEvent event) throws IOException
  85         {
  86         }
  87
  88         @Override
  89         public void onComplete(AsyncEvent event) throws IOException
  90         {
  91             HttpChannelState state = ((AsyncContextEvent)event).getHttpChannelState();
  92
  93             Request request = state.getBaseRequest();
  94             final long elapsed = System.currentTimeMillis()-request.getTimeStamp();
  95
  96             long d=_requestStats.decrement();
  97             _requestTimeStats.set(elapsed);
  98
  99             updateResponse(request);
 100
 101             _asyncWaitStats.decrement();
 102
 103             // If we have no more dispatches, should we signal shutdown?
 104             if (d==0)
 105             {
 106                 FutureCallback shutdown = _shutdown.get();
 107                 if (shutdown!=null)
 108                     shutdown.succeeded();
 109             }
 110         }
 111     };
 112
 113     /**
 114      * Resets the current request statistics.
 115      */
 116     @ManagedOperation(value="resets statistics", impact="ACTION")
 117     public void statsReset()
 118     {
 119         _statsStartedAt.set(System.currentTimeMillis());
 120
 121         _requestStats.reset();
 122         _requestTimeStats.reset();
 123         _dispatchedStats.reset();
 124         _dispatchedTimeStats.reset();
 125         _asyncWaitStats.reset();
 126
 127         _asyncDispatches.set(0);
 128         _expires.set(0);
 129         _responses1xx.set(0);
 130         _responses2xx.set(0);
 131         _responses3xx.set(0);
 132         _responses4xx.set(0);
 133         _responses5xx.set(0);
 134         _responsesTotalBytes.set(0L);
 135     }
 136
 137     @Override
 138     public void handle(String path, Request request, HttpServletRequest httpRequest, HttpServletResponse httpResponse) throws IOException, ServletException
 139     {
 140         _dispatchedStats.increment();
 141
 142         final long start;
 143         HttpChannelState state = request.getHttpChannelState();
 144         if (state.isInitial())
 145         {
 146             // new request
 147             _requestStats.increment();
 148             start = request.getTimeStamp();
 149         }
 150         else
 151         {
 152             // resumed request
 153             start = System.currentTimeMillis();
 154             _asyncDispatches.incrementAndGet();
 155         }
 156
 157         try
 158         {
 159             super.handle(path, request, httpRequest, httpResponse);
 160         }
 161         finally
 162         {
 163             final long now = System.currentTimeMillis();
 164             final long dispatched=now-start;
 165
 166             _dispatchedStats.decrement();
 167             _dispatchedTimeStats.set(dispatched);
 168
 169             if (state.isSuspended())
 170             {
 171                 if (state.isInitial())
 172                 {
 173                     state.addListener(_onCompletion);
 174                     _asyncWaitStats.increment();
 175                 }
 176             }
 177             else if (state.isInitial())
 178             {
 179                 long d=_requestStats.decrement();
 180                 _requestTimeStats.set(dispatched);
 181                 updateResponse(request);
 182
 183                 // If we have no more dispatches, should we signal shutdown?
 184                 FutureCallback shutdown = _shutdown.get();
 185                 if (shutdown!=null)
 186                 {
 187                     httpResponse.flushBuffer();
 188                     if (d==0)
 189                         shutdown.succeeded();
 190                 }
 191             }
 192             // else onCompletion will handle it.
 193         }
 194     }
 195
 196     private void updateResponse(Request request)
 197     {
 198         Response response = request.getResponse();
 199         switch (response.getStatus() / 100)
 200         {
 201             case 0:
 202                 if (request.isHandled())
 203                     _responses2xx.incrementAndGet();
 204                 else
 205                     _responses4xx.incrementAndGet();
 206                 break;
 207             case 1:
 208                 _responses1xx.incrementAndGet();
 209                 break;
 210             case 2:
 211                 _responses2xx.incrementAndGet();
 212                 break;
 213             case 3:
 214                 _responses3xx.incrementAndGet();
 215                 break;
 216             case 4:
 217                 _responses4xx.incrementAndGet();
 218                 break;
 219             case 5:
 220                 _responses5xx.incrementAndGet();
 221                 break;
 222             default:
 223                 break;
 224         }
 225         _responsesTotalBytes.addAndGet(response.getContentCount());
 226     }
 227
 228     @Override
 229     protected void doStart() throws Exception
 230     {
 231         _shutdown.set(null);
 232         super.doStart();
 233         statsReset();
 234     }
 235
 236
 237     @Override
 238     protected void doStop() throws Exception
 239     {
 240         super.doStop();
 241         FutureCallback shutdown = _shutdown.get();
 242         if (shutdown!=null && !shutdown.isDone())
 243             shutdown.failed(new TimeoutException());
 244     }
 245
 246     /**
 247      * @return the number of requests handled by this handler
 248      * since {@link #statsReset()} was last called, excluding
 249      * active requests
 250      * @see #getAsyncDispatches()
 251      */
 252     @ManagedAttribute("number of requests")
 253     public int getRequests()
 254     {
 255         return (int)_requestStats.getTotal();
 256     }
 257
 258     /**
 259      * @return the number of requests currently active.
 260      * since {@link #statsReset()} was last called.
 261      */
 262     @ManagedAttribute("number of requests currently active")
 263     public int getRequestsActive()
 264     {
 265         return (int)_requestStats.getCurrent();
 266     }
 267
 268     /**
 269      * @return the maximum number of active requests
 270      * since {@link #statsReset()} was last called.
 271      */
 272     @ManagedAttribute("maximum number of active requests")
 273     public int getRequestsActiveMax()
 274     {
 275         return (int)_requestStats.getMax();
 276     }
 277
 278     /**
 279      * @return the maximum time (in milliseconds) of request handling
 280      * since {@link #statsReset()} was last called.
 281      */
 282     @ManagedAttribute("maximum time spend handling requests (in ms)")
 283     public long getRequestTimeMax()
 284     {
 285         return _requestTimeStats.getMax();
 286     }
 287
 288     /**
 289      * @return the total time (in milliseconds) of requests handling
 290      * since {@link #statsReset()} was last called.
 291      */
 292     @ManagedAttribute("total time spend in all request handling (in ms)")
 293     public long getRequestTimeTotal()
 294     {
 295         return _requestTimeStats.getTotal();
 296     }
 297
 298     /**
 299      * @return the mean time (in milliseconds) of request handling
 300      * since {@link #statsReset()} was last called.
 301      * @see #getRequestTimeTotal()
 302      * @see #getRequests()
 303      */
 304     @ManagedAttribute("mean time spent handling requests (in ms)")
 305     public double getRequestTimeMean()
 306     {
 307         return _requestTimeStats.getMean();
 308     }
 309
 310     /**
 311      * @return the standard deviation of time (in milliseconds) of request handling
 312      * since {@link #statsReset()} was last called.
 313      * @see #getRequestTimeTotal()
 314      * @see #getRequests()
 315      */
 316     @ManagedAttribute("standard deviation for request handling (in ms)")
 317     public double getRequestTimeStdDev()
 318     {
 319         return _requestTimeStats.getStdDev();
 320     }
 321
 322     /**
 323      * @return the number of dispatches seen by this handler
 324      * since {@link #statsReset()} was last called, excluding
 325      * active dispatches
 326      */
 327     @ManagedAttribute("number of dispatches")
 328     public int getDispatched()
 329     {
 330         return (int)_dispatchedStats.getTotal();
 331     }
 332
 333     /**
 334      * @return the number of dispatches currently in this handler
 335      * since {@link #statsReset()} was last called, including
 336      * resumed requests
 337      */
 338     @ManagedAttribute("number of dispatches currently active")
 339     public int getDispatchedActive()
 340     {
 341         return (int)_dispatchedStats.getCurrent();
 342     }
 343
 344     /**
 345      * @return the max number of dispatches currently in this handler
 346      * since {@link #statsReset()} was last called, including
 347      * resumed requests
 348      */
 349     @ManagedAttribute("maximum number of active dispatches being handled")
 350     public int getDispatchedActiveMax()
 351     {
 352         return (int)_dispatchedStats.getMax();
 353     }
 354
 355     /**
 356      * @return the maximum time (in milliseconds) of request dispatch
 357      * since {@link #statsReset()} was last called.
 358      */
 359     @ManagedAttribute("maximum time spend in dispatch handling")
 360     public long getDispatchedTimeMax()
 361     {
 362         return _dispatchedTimeStats.getMax();
 363     }
 364
 365     /**
 366      * @return the total time (in milliseconds) of requests handling
 367      * since {@link #statsReset()} was last called.
 368      */
 369     @ManagedAttribute("total time spent in dispatch handling (in ms)")
 370     public long getDispatchedTimeTotal()
 371     {
 372         return _dispatchedTimeStats.getTotal();
 373     }
 374
 375     /**
 376      * @return the mean time (in milliseconds) of request handling
 377      * since {@link #statsReset()} was last called.
 378      * @see #getRequestTimeTotal()
 379      * @see #getRequests()
 380      */
 381     @ManagedAttribute("mean time spent in dispatch handling (in ms)")
 382     public double getDispatchedTimeMean()
 383     {
 384         return _dispatchedTimeStats.getMean();
 385     }
 386
 387     /**
 388      * @return the standard deviation of time (in milliseconds) of request handling
 389      * since {@link #statsReset()} was last called.
 390      * @see #getRequestTimeTotal()
 391      * @see #getRequests()
 392      */
 393     @ManagedAttribute("standard deviation for dispatch handling (in ms)")
 394     public double getDispatchedTimeStdDev()
 395     {
 396         return _dispatchedTimeStats.getStdDev();
 397     }
 398
 399     /**
 400      * @return the number of requests handled by this handler
 401      * since {@link #statsReset()} was last called, including
 402      * resumed requests
 403      * @see #getAsyncDispatches()
 404      */
 405     @ManagedAttribute("total number of async requests")
 406     public int getAsyncRequests()
 407     {
 408         return (int)_asyncWaitStats.getTotal();
 409     }
 410
 411     /**
 412      * @return the number of requests currently suspended.
 413      * since {@link #statsReset()} was last called.
 414      */
 415     @ManagedAttribute("currently waiting async requests")
 416     public int getAsyncRequestsWaiting()
 417     {
 418         return (int)_asyncWaitStats.getCurrent();
 419     }
 420
 421     /**
 422      * @return the maximum number of current suspended requests
 423      * since {@link #statsReset()} was last called.
 424      */
 425     @ManagedAttribute("maximum number of waiting async requests")
 426     public int getAsyncRequestsWaitingMax()
 427     {
 428         return (int)_asyncWaitStats.getMax();
 429     }
 430
 431     /**
 432      * @return the number of requests that have been asynchronously dispatched
 433      */
 434     @ManagedAttribute("number of requested that have been asynchronously dispatched")
 435     public int getAsyncDispatches()
 436     {
 437         return _asyncDispatches.get();
 438     }
 439
 440     /**
 441      * @return the number of requests that expired while suspended.
 442      * @see #getAsyncDispatches()
 443      */
 444     @ManagedAttribute("number of async requests requests that have expired")
 445     public int getExpires()
 446     {
 447         return _expires.get();
 448     }
 449
 450     /**
 451      * @return the number of responses with a 1xx status returned by this context
 452      * since {@link #statsReset()} was last called.
 453      */
 454     @ManagedAttribute("number of requests with 1xx response status")
 455     public int getResponses1xx()
 456     {
 457         return _responses1xx.get();
 458     }
 459
 460     /**
 461      * @return the number of responses with a 2xx status returned by this context
 462      * since {@link #statsReset()} was last called.
 463      */
 464     @ManagedAttribute("number of requests with 2xx response status")
 465     public int getResponses2xx()
 466     {
 467         return _responses2xx.get();
 468     }
 469
 470     /**
 471      * @return the number of responses with a 3xx status returned by this context
 472      * since {@link #statsReset()} was last called.
 473      */
 474     @ManagedAttribute("number of requests with 3xx response status")
 475     public int getResponses3xx()
 476     {
 477         return _responses3xx.get();
 478     }
 479
 480     /**
 481      * @return the number of responses with a 4xx status returned by this context
 482      * since {@link #statsReset()} was last called.
 483      */
 484     @ManagedAttribute("number of requests with 4xx response status")
 485     public int getResponses4xx()
 486     {
 487         return _responses4xx.get();
 488     }
 489
 490     /**
 491      * @return the number of responses with a 5xx status returned by this context
 492      * since {@link #statsReset()} was last called.
 493      */
 494     @ManagedAttribute("number of requests with 5xx response status")
 495     public int getResponses5xx()
 496     {
 497         return _responses5xx.get();
 498     }
 499
 500     /**
 501      * @return the milliseconds since the statistics were started with {@link #statsReset()}.
 502      */
 503     @ManagedAttribute("time in milliseconds stats have been collected for")
 504     public long getStatsOnMs()
 505     {
 506         return System.currentTimeMillis() - _statsStartedAt.get();
 507     }
 508
 509     /**
 510      * @return the total bytes of content sent in responses
 511      */
 512     @ManagedAttribute("total number of bytes across all responses")
 513     public long getResponsesBytesTotal()
 514     {
 515         return _responsesTotalBytes.get();
 516     }
 517
 518     public String toStatsHTML()
 519     {
 520         StringBuilder sb = new StringBuilder();
 521
 522         sb.append("<h1>Statistics:</h1>\n");
 523         sb.append("Statistics gathering started ").append(getStatsOnMs()).append("ms ago").append("<br />\n");
 524
 525         sb.append("<h2>Requests:</h2>\n");
 526         sb.append("Total requests: ").append(getRequests()).append("<br />\n");
 527         sb.append("Active requests: ").append(getRequestsActive()).append("<br />\n");
 528         sb.append("Max active requests: ").append(getRequestsActiveMax()).append("<br />\n");
 529         sb.append("Total requests time: ").append(getRequestTimeTotal()).append("<br />\n");
 530         sb.append("Mean request time: ").append(getRequestTimeMean()).append("<br />\n");
 531         sb.append("Max request time: ").append(getRequestTimeMax()).append("<br />\n");
 532         sb.append("Request time standard deviation: ").append(getRequestTimeStdDev()).append("<br />\n");
 533
 534
 535         sb.append("<h2>Dispatches:</h2>\n");
 536         sb.append("Total dispatched: ").append(getDispatched()).append("<br />\n");
 537         sb.append("Active dispatched: ").append(getDispatchedActive()).append("<br />\n");
 538         sb.append("Max active dispatched: ").append(getDispatchedActiveMax()).append("<br />\n");
 539         sb.append("Total dispatched time: ").append(getDispatchedTimeTotal()).append("<br />\n");
 540         sb.append("Mean dispatched time: ").append(getDispatchedTimeMean()).append("<br />\n");
 541         sb.append("Max dispatched time: ").append(getDispatchedTimeMax()).append("<br />\n");
 542         sb.append("Dispatched time standard deviation: ").append(getDispatchedTimeStdDev()).append("<br />\n");
 543
 544
 545         sb.append("Total requests suspended: ").append(getAsyncRequests()).append("<br />\n");
 546         sb.append("Total requests expired: ").append(getExpires()).append("<br />\n");
 547         sb.append("Total requests resumed: ").append(getAsyncDispatches()).append("<br />\n");
 548
 549         sb.append("<h2>Responses:</h2>\n");
 550         sb.append("1xx responses: ").append(getResponses1xx()).append("<br />\n");
 551         sb.append("2xx responses: ").append(getResponses2xx()).append("<br />\n");
 552         sb.append("3xx responses: ").append(getResponses3xx()).append("<br />\n");
 553         sb.append("4xx responses: ").append(getResponses4xx()).append("<br />\n");
 554         sb.append("5xx responses: ").append(getResponses5xx()).append("<br />\n");
 555         sb.append("Bytes sent total: ").append(getResponsesBytesTotal()).append("<br />\n");
 556
 557         return sb.toString();
 558
 559     }
 560
 561     @Override
 562     public Future<Void> shutdown()
 563     {
 564         FutureCallback shutdown=new FutureCallback(false);
 565         _shutdown.compareAndSet(null,shutdown);
 566         shutdown=_shutdown.get();
 567         if (_dispatchedStats.getCurrent()==0)
 568             shutdown.succeeded();
 569         return shutdown;
 570     }
 571 }