Changeset 1ede072


Ignore:
Timestamp:
2006-07-31 22:49:29 (8 years ago)
Author:
Poul-Henning Kamp <phk@…>
Branches:
master, 1.0, 1.1, 1.2, 3.0, 4.0, experimental-ims, tags/1.0, tags/varnish-0.9, tags/varnish-0.9.1, tags/varnish-0.9.1@805, tags/varnish-0.9@787, tags/varnish-1.0, tags/varnish-1.0.1, tags/varnish-1.0.2, tags/varnish-1.0.3, tags/varnish-1.0.4, tags/varnish-1.1, tags/varnish-1.1.1, tags/varnish-1.1.2
Children:
09bf7d5
Parents:
edae64
git-author:
Poul-Henning Kamp <phk@…> (2006-07-31 22:49:29)
git-committer:
Poul-Henning Kamp <phk@…> (2006-07-31 22:49:29)
Message:

Create three groups of seven SHMlog tags:

{Rx,Tx,Obj}{Request,Response,Status,URL,Protocol,Header,LostHeader?}

And log http header munching accordingly.

git-svn-id:  http://www.varnish-cache.org/svn/trunk/varnish-cache@580 d4fa192b-c00b-0410-8231-f00ffab90ce4

Files:
6 edited

Legend:

Unmodified
Added
Removed
  • bin/varnishd/cache.h

    rf13a521 r1ede072  
    6868 
    6969        unsigned char           conds;          /* If-* headers present */ 
    70         unsigned char           objlog; 
     70        enum httpwhence { 
     71                HTTP_Rx, 
     72                HTTP_Tx, 
     73                HTTP_Obj 
     74        }                       logtag; 
    7175 
    7276        struct http_hdr         hd[MAX_HTTP_HDRS]; 
  • bin/varnishd/cache_fetch.c

    rf13a521 r1ede072  
    230230         */ 
    231231        http_ClrHeader(sp->http); 
    232         sp->http->objlog = 1;   /* log as SLT_ObjHeader */ 
     232        sp->http->logtag = HTTP_Obj; 
    233233        http_CopyResp(sp->fd, sp->http, vc->http); 
    234234        http_FilterHeader(sp->fd, sp->http, vc->http, HTTPH_A_INS); 
     
    245245        } else 
    246246                cls = 0; 
    247         sp->http->objlog = 0; 
    248247        http_CopyHttp(&sp->obj->http, sp->http); 
    249248 
     
    283282        VSL(SLT_Backend, sp->fd, "%d %s", vc->fd, sp->backend->vcl_name); 
    284283 
     284        http_ClrHeader(vc->http); 
     285        vc->http->logtag = HTTP_Tx; 
    285286        http_GetReq(vc->fd, vc->http, sp->http); 
    286287        http_FilterHeader(vc->fd, vc->http, sp->http, HTTPH_R_FETCH); 
  • bin/varnishd/cache_http.c

    rf13a521 r1ede072  
    2020#undef HTTPH 
    2121 
     22enum httptag { 
     23        HTTP_T_Request, 
     24        HTTP_T_Response, 
     25        HTTP_T_Status, 
     26        HTTP_T_URL, 
     27        HTTP_T_Protocol, 
     28        HTTP_T_Header, 
     29        HTTP_T_LostHeader, 
     30}; 
     31 
     32#define LOGMTX2(ax, bx)         \ 
     33        [HTTP_T_##bx] = SLT_##ax##bx 
     34 
     35#define LOGMTX1(ax) {           \ 
     36        LOGMTX2(ax, Request),   \ 
     37        LOGMTX2(ax, Response),  \ 
     38        LOGMTX2(ax, Status),    \ 
     39        LOGMTX2(ax, URL),       \ 
     40        LOGMTX2(ax, Protocol),  \ 
     41        LOGMTX2(ax, Header),    \ 
     42        LOGMTX2(ax, LostHeader) \ 
     43        } 
     44 
     45static enum shmlogtag logmtx[3][7] = { 
     46        [HTTP_Rx] = LOGMTX1(Rx), 
     47        [HTTP_Tx] = LOGMTX1(Tx), 
     48        [HTTP_Obj] = LOGMTX1(Obj) 
     49}; 
     50 
     51static enum shmlogtag 
     52T(struct http *hp, enum httptag t) 
     53{ 
     54 
     55        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC); 
     56        assert(hp->logtag >= HTTP_Rx && hp->logtag <= HTTP_Obj); 
     57        assert(t >= HTTP_T_Request && t <= HTTP_T_LostHeader); 
     58        return (logmtx[hp->logtag][t]); 
     59} 
     60 
    2261#define VSLH(ax, bx, cx, dx) \ 
    23         VSLR((ax), (bx), (cx)->hd[(dx)].b, (cx)->hd[(dx)].e); 
    24  
    25 #define VSLHT(bx, cx, dx) \ 
    26         VSLH((cx)->objlog ? SLT_ObjHeader : SLT_TxHeader, bx, cx, dx) 
     62        VSLR(T((cx), (ax)), (bx), (cx)->hd[(dx)].b, (cx)->hd[(dx)].e); 
    2763 
    2864/*--------------------------------------------------------------------*/ 
     
    242278                        hp->hd[hp->nhd].b = p; 
    243279                        hp->hd[hp->nhd].e = q; 
    244                         VSLH(SLT_RxHeader, fd, hp, hp->nhd); 
     280                        VSLH(HTTP_T_Header, fd, hp, hp->nhd); 
    245281                        hp->nhd++; 
    246282                } else { 
    247283                        VSL_stats->losthdr++; 
    248                         VSLR(SLT_LostHeader, fd, p, q); 
     284                        VSLR(T(hp, HTTP_T_LostHeader), fd, p, q); 
    249285                } 
    250286        } 
     
    264300        assert(hp->s < hp->t); 
    265301        assert(hp->t <= hp->v); 
     302        hp->logtag = HTTP_Rx; 
     303 
    266304        for (p = hp->s ; isspace(*p); p++) 
    267305                continue; 
     
    272310                ; 
    273311        hp->hd[HTTP_HDR_REQ].e = p; 
    274         VSLH(SLT_Request, fd, hp, HTTP_HDR_REQ); 
     312        VSLH(HTTP_T_Request, fd, hp, HTTP_HDR_REQ); 
    275313        *p++ = '\0'; 
    276314 
     
    286324                p++; 
    287325        hp->hd[HTTP_HDR_URL].e = p; 
    288         VSLH(SLT_URL, fd, hp, HTTP_HDR_URL); 
     326        VSLH(HTTP_T_URL, fd, hp, HTTP_HDR_URL); 
    289327        if (*p == '\n') { 
    290328                VSLR(SLT_HttpGarbage, fd, hp->s, hp->v); 
     
    304342                p++; 
    305343        hp->hd[HTTP_HDR_PROTO].e = p; 
    306         VSLH(SLT_Protocol, fd, hp, HTTP_HDR_PROTO); 
     344        VSLH(HTTP_T_Protocol, fd, hp, HTTP_HDR_PROTO); 
    307345        if (*p != '\n') 
    308346                *p++ = '\0'; 
     
    328366        assert(hp->s < hp->t); 
    329367        assert(hp->t <= hp->v); 
     368        hp->logtag = HTTP_Rx; 
     369 
    330370        for (p = hp->s ; isspace(*p); p++) 
    331371                continue; 
     
    336376                p++; 
    337377        hp->hd[HTTP_HDR_PROTO].e = p; 
    338         VSLH(SLT_Protocol, fd, hp, HTTP_HDR_PROTO); 
     378        VSLH(HTTP_T_Protocol, fd, hp, HTTP_HDR_PROTO); 
    339379        *p++ = '\0'; 
    340380 
     
    346386                p++; 
    347387        hp->hd[HTTP_HDR_STATUS].e = p; 
    348         VSLH(SLT_Status, fd, hp, HTTP_HDR_STATUS); 
     388        VSLH(HTTP_T_Status, fd, hp, HTTP_HDR_STATUS); 
    349389        *p++ = '\0'; 
    350390 
     
    360400        *q = '\0'; 
    361401        hp->hd[HTTP_HDR_RESPONSE].e = q; 
    362         VSLH(SLT_Response, fd, hp, HTTP_HDR_RESPONSE); 
     402        VSLH(HTTP_T_Response, fd, hp, HTTP_HDR_RESPONSE); 
    363403        p++; 
    364404 
     
    527567 
    528568static void 
    529 http_seth(int fd, struct http *to, unsigned n, enum shmlogtag tag, const char *fm) 
     569http_seth(int fd, struct http *to, unsigned n, enum httptag tag, const char *fm) 
    530570{ 
    531571        assert(n < MAX_HTTP_HDRS); 
    532572        assert(fm != NULL); 
    533573        to->hd[n].b = (void*)(uintptr_t)fm; 
    534         to->hd[n].e = strchr(fm, '\0'); 
     574        to->hd[n].e = (void*)(uintptr_t)strchr(fm, '\0'); 
    535575        VSLH(tag, fd, to, n); 
    536576} 
    537577 
    538578static void 
    539 http_copyh(int fd, struct http *to, struct http *fm, unsigned n, enum shmlogtag tag) 
     579http_copyh(int fd, struct http *to, struct http *fm, unsigned n, enum httptag tag) 
    540580{ 
    541581 
     
    553593        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC); 
    554594        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC); 
    555         http_seth(fd, to, HTTP_HDR_REQ, SLT_Request, "GET"); 
    556         http_copyh(fd, to, fm, HTTP_HDR_URL, SLT_URL); 
    557         http_seth(fd, to, HTTP_HDR_PROTO, SLT_Protocol, "HTTP/1.1"); 
     595        http_seth(fd, to, HTTP_HDR_REQ, HTTP_T_Request, "GET"); 
     596        http_copyh(fd, to, fm, HTTP_HDR_URL, HTTP_T_URL); 
     597        http_seth(fd, to, HTTP_HDR_PROTO, HTTP_T_Protocol, "HTTP/1.1"); 
    558598} 
    559599 
     
    564604        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC); 
    565605        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC); 
    566         http_copyh(fd, to, fm, HTTP_HDR_REQ, SLT_Request); 
    567         http_copyh(fd, to, fm, HTTP_HDR_URL, SLT_URL); 
    568         http_copyh(fd, to, fm, HTTP_HDR_PROTO, SLT_Protocol); 
     606        http_copyh(fd, to, fm, HTTP_HDR_REQ, HTTP_T_Request); 
     607        http_copyh(fd, to, fm, HTTP_HDR_URL, HTTP_T_URL); 
     608        http_copyh(fd, to, fm, HTTP_HDR_PROTO, HTTP_T_Protocol); 
    569609} 
    570610 
     
    576616        CHECK_OBJ_NOTNULL(fm, HTTP_MAGIC); 
    577617        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC); 
    578         http_copyh(fd, to, fm, HTTP_HDR_PROTO, SLT_Protocol); 
    579         http_copyh(fd, to, fm, HTTP_HDR_STATUS, SLT_Status); 
    580         http_copyh(fd, to, fm, HTTP_HDR_RESPONSE, SLT_Response); 
     618        http_copyh(fd, to, fm, HTTP_HDR_PROTO, HTTP_T_Protocol); 
     619        http_copyh(fd, to, fm, HTTP_HDR_STATUS, HTTP_T_Status); 
     620        http_copyh(fd, to, fm, HTTP_HDR_RESPONSE, HTTP_T_Response); 
    581621} 
    582622 
     
    585625{ 
    586626        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC); 
    587         http_seth(fd, to, HTTP_HDR_PROTO, SLT_Protocol, proto); 
    588         http_seth(fd, to, HTTP_HDR_STATUS, SLT_Status, status); 
    589         http_seth(fd, to, HTTP_HDR_RESPONSE, SLT_Response, response); 
     627        http_seth(fd, to, HTTP_HDR_PROTO, HTTP_T_Protocol, proto); 
     628        http_seth(fd, to, HTTP_HDR_STATUS, HTTP_T_Status, status); 
     629        http_seth(fd, to, HTTP_HDR_RESPONSE, HTTP_T_Response, response); 
    590630} 
    591631 
     
    601641                to->hd[to->nhd].b = fm->hd[n].b; 
    602642                to->hd[to->nhd].e = fm->hd[n].e; 
    603                 VSLHT(fd, to, to->nhd); 
     643                VSLH(HTTP_T_Header, fd, to, to->nhd); 
    604644                to->nhd++; 
    605645        } else  { 
    606646                VSL_stats->losthdr++; 
    607                 VSLH(SLT_LostHeader, fd, fm, n); 
     647                VSLH(HTTP_T_LostHeader, fd, fm, n); 
    608648        } 
    609649} 
     
    646686 
    647687        CHECK_OBJ_NOTNULL(to, HTTP_MAGIC); 
    648         to->hd[to->nhd].b = (void*)(uintptr_t)hdr; 
    649         to->hd[to->nhd].e = strchr(hdr, '\0'); 
    650         assert(to->hd[to->nhd].e != NULL); 
    651         VSLHT(fd, to, to->nhd); 
    652         to->nhd++; 
     688        if (to->nhd >= MAX_HTTP_HDRS) { 
     689                VSL_stats->losthdr++; 
     690                VSL(T(to, HTTP_T_LostHeader), fd, "%s", hdr); 
     691                return; 
     692        } 
     693        http_seth(fd, to, to->nhd++, HTTP_T_Header, hdr); 
    653694} 
    654695 
     
    667708        if (n + 1 > l || to->nhd >= MAX_HTTP_HDRS) { 
    668709                VSL_stats->losthdr++; 
    669                 VSL(SLT_LostHeader, fd, "%s", to->f); 
     710                VSL(T(to, HTTP_T_LostHeader), fd, "%s", to->f); 
    670711        } else { 
    671712                assert(to->f < to->e); 
     
    673714                to->hd[to->nhd].e = to->f + n; 
    674715                to->f += n + 1; 
    675                 VSLHT(fd, to, to->nhd); 
     716                VSLH(HTTP_T_Header, fd, to, to->nhd); 
    676717                to->nhd++; 
    677718        } 
  • bin/varnishd/cache_response.c

    rf13a521 r1ede072  
    8383 
    8484        http_ClrHeader(sp->http); 
     85        sp->http->logtag = HTTP_Tx; 
    8586        http_SetResp(sp->fd, sp->http, "HTTP/1.1", "304", "Not Modified"); 
    8687        http_SetHeader(sp->fd, sp->http, "Via: 1.1 varnish"); 
     
    135136 
    136137        http_ClrHeader(sp->http); 
     138        sp->http->logtag = HTTP_Tx; 
    137139        http_CopyResp(sp->fd, sp->http, &sp->obj->http); 
    138140        http_FilterHeader(sp->fd, sp->http, &sp->obj->http, HTTPH_A_DELIVER); 
  • bin/varnishlog/varnishlog.c

    rcd8559 r1ede072  
    127127                        v = 1; 
    128128                break; 
    129         case SLT_Request: 
     129        case SLT_RxRequest: 
    130130                if (h_opt && p[1] == 3 && !memcmp(p + 4, "GET", 3)) 
    131131                        hc[u]++; 
     
    138138                v = 1; 
    139139                break; 
    140         case SLT_Status: 
     140        case SLT_RxStatus: 
    141141                if (h_opt && p[1] == 3 && !memcmp(p + 4, "200", 3)) 
    142142                        hc[u]++; 
  • include/shmlog_tags.h

    re698fe r1ede072  
    2525SLTM(ClientAddr) 
    2626SLTM(Backend) 
    27 SLTM(Request) 
    28 SLTM(Response) 
    2927SLTM(Length) 
    30 SLTM(Status) 
    31 SLTM(URL) 
    32 SLTM(Protocol) 
     28 
     29SLTM(RxRequest) 
     30SLTM(RxResponse) 
     31SLTM(RxStatus) 
     32SLTM(RxURL) 
     33SLTM(RxProtocol) 
    3334SLTM(RxHeader) 
     35SLTM(RxLostHeader) 
     36 
     37SLTM(TxRequest) 
     38SLTM(TxResponse) 
     39SLTM(TxStatus) 
     40SLTM(TxURL) 
     41SLTM(TxProtocol) 
    3442SLTM(TxHeader) 
     43SLTM(TxLostHeader) 
     44 
     45SLTM(ObjRequest) 
     46SLTM(ObjResponse) 
     47SLTM(ObjStatus) 
     48SLTM(ObjURL) 
     49SLTM(ObjProtocol) 
    3550SLTM(ObjHeader) 
    36 SLTM(LostHeader) 
     51SLTM(ObjLostHeader) 
     52 
    3753SLTM(TTL) 
    3854SLTM(VCL_acl) 
Note: See TracChangeset for help on using the changeset viewer.