$bytes_sent、$body_bytes_sent、$content_length、$request_length、$upstream_response_길이

10068 단어
기본 적 의미
  • $bytes_sent (1.3.8, 1.2.5): nginx 가 클 라 이언 트 에 게 되 돌려 주 는 바이트 수 는 응답 헤드 와 응답 체 를 포함 합 니 다
  • $body_bytes_sent: nginx 는 클 라 이언 트 에 대한 응답 체 의 바이트 수 를 되 돌려 줍 니 다 (즉, 응답 헤드 가 포함 되 지 않 음)
  • $content_length: "Content - Length" 요청 헤드 의 값 은 $http 와 같 습 니 다.content_length。즉, nginx 가 클 라 이언 트 로부터 받 은 요청 헤더 에서 Content - Length 필드 의 값 은 nginx 가 클 라 이언 트 응답 에 있 는 Content - Length 필드 ($sent http content length) 의 값 을 되 돌려 주 는 것 이 아 닙 니 다
  • $request_length (1.3.12, 1.2.7): 요청 한 바이트 수 (요청 줄, 요청 헤더, 요청 체 포함).주의, $requestlength 는 분석 을 요청 하 는 과정 에서 계속 누적 되 며, 요청 을 분석 할 때 이상 이 발생 하거나 미리 완료 되면 $requestlength 는 이미 누 적 된 부분의 길이 일 뿐 nginx 가 클 라 이언 트 로부터 받 은 전체 요청 의 총 바이트 수 (요청 줄, 요청 헤드, 요청 체 포함) 가 아 닙 니 다.예 를 들 어 nginx 의 정적 파일 에 대한 URL POST 데 이 터 는 POST 의 데이터 (즉 요청 체) 가 계산 되 지 않 습 니 다
  • $upstream_response_length (0.7.27): upstream 서버 에서 받 은 응답 체 의 바이트 수 를 저장 합 니 다. 응답 헤드 를 포함 하지 않 고 1.11.4 에 추 가 된 $upstreambytes_received 변 수 는 응답 헤드 를 포함 합 니 다.응답 길이 가 여러 개 있 으 면 쉼표 와 콜론 으로 구분 합 니 다. $upstreamaddr 의 주소 처럼..

  • 코드 분석
    주의: 코드 버 전 은 nginx - 1.10.2 입 니 다.
    $bytes_sent
    변수 처리 코드:
    static ngx_int_t
    ngx_http_variable_bytes_sent(ngx_http_request_t *r,
        ngx_http_variable_value_t *v, uintptr_t data)
    {
        u_char  *p;
    
        p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
        if (p == NULL) {
            return NGX_ERROR;
        }
    
        v->len = ngx_sprintf(p, "%O", r->connection->sent) - p;
        v->valid = 1;
        v->no_cacheable = 0;
        v->not_found = 0;
        v->data = p;
    
        return NGX_OK;
    }
    

    코드 에서 $bytes 를 볼 수 있 습 니 다.sent 는 r - > connection - > sent 입 니 다. 클 라 이언 트 에 게 보 내 는 모든 바이트 수 입 니 다.
    $body_bytes_sent
    변수 처리 코드:
    static ngx_int_t
    ngx_http_variable_body_bytes_sent(ngx_http_request_t *r,
        ngx_http_variable_value_t *v, uintptr_t data)
    {
        off_t    sent;
        u_char  *p;
    
        sent = r->connection->sent - r->header_size;
    
        if (sent < 0) {
            sent = 0;
        }
    
        p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
        if (p == NULL) {
            return NGX_ERROR;
        }
    
        v->len = ngx_sprintf(p, "%O", sent) - p;
        v->valid = 1;
        v->no_cacheable = 0;
        v->not_found = 0;
        v->data = p;
    
        return NGX_OK;
    }
    

    코드 에서 $body 를 볼 수 있 습 니 다.bytes_sent 는 r - > connection - > sent 빼 기 r - > headersize (응답 체), 즉 응답 체 의 바이트 수 입 니 다.
    $content_length
    변수 처리 코드:
    static ngx_int_t
    ngx_http_variable_content_length(ngx_http_request_t *r,
        ngx_http_variable_value_t *v, uintptr_t data)
    {
        u_char  *p;
    
        if (r->headers_in.content_length) {
            v->len = r->headers_in.content_length->value.len;
            v->data = r->headers_in.content_length->value.data;
            v->valid = 1;
            v->no_cacheable = 0;
            v->not_found = 0;
    
        } else if (r->reading_body) {
            v->not_found = 1;
            v->no_cacheable = 1;
    
        } else if (r->headers_in.content_length_n >= 0) {
            p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
            if (p == NULL) {
                return NGX_ERROR;
            }
    
            v->len = ngx_sprintf(p, "%O", r->headers_in.content_length_n) - p;
            v->data = p;
            v->valid = 1;
            v->no_cacheable = 0;
            v->not_found = 0;
    
        } else {
            v->not_found = 1;
        }
    
        return NGX_OK;
    }
    

    $content_length 는 r - > headersin 중의 contentlength 또는 contentlength_n 의 값 은 r - > headers 가 아 닙 니 다.out 의 contentlength, 그래서 요청 을 받 은 Content - length 입 니 다.
    $request_length
    변수 처리 코드:
    static ngx_int_t
    ngx_http_variable_request_length(ngx_http_request_t *r,
        ngx_http_variable_value_t *v, uintptr_t data)
    {
        u_char  *p;
    
        p = ngx_pnalloc(r->pool, NGX_OFF_T_LEN);
        if (p == NULL) {
            return NGX_ERROR;
        }
    
        v->len = ngx_sprintf(p, "%O", r->request_length) - p;
        v->valid = 1;
        v->no_cacheable = 0;
        v->not_found = 0;
        v->data = p;
    
        return NGX_OK;
    }
    

    $request_length 는 r - > requestlength 의 값 분석 요청 줄 코드:
            rc = ngx_http_parse_request_line(r, r->header_in);
    
            if (rc == NGX_OK) {
    
                /* the request line has been parsed successfully */
    
                r->request_line.len = r->request_end - r->request_start;
                r->request_line.data = r->request_start;
                r->request_length = r->header_in->pos - r->request_start;
    
                ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                               "http request line: \"%V\"", &r->request_line);
    
                r->method_name.len = r->method_end - r->request_start + 1;
                r->method_name.data = r->request_line.data;
                ......
            }
    

    r->request_length 가 요청 줄 의 길이 로 초기 화 되 었 습 니 다.요청 헤더 처리 코드:
        for ( ;; ) {
            ......
    
            if (rc == NGX_OK) {
    
                r->request_length += r->header_in->pos - r->header_name_start;
    
                ......
    
                /* a header line has been parsed successfully */
    
                h = ngx_list_push(&r->headers_in.headers);
                ......
    
                continue;
            }
    
            if (rc == NGX_HTTP_PARSE_HEADER_DONE) {
    
                /* a whole header has been parsed successfully */
    
                ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                               "http header done");
    
                r->request_length += r->header_in->pos - r->header_name_start;
    
                r->http_state = NGX_HTTP_PROCESS_REQUEST_STATE;
    
                rc = ngx_http_process_request_header(r);
    
                if (rc != NGX_OK) {
                    return;
                }
    
                ngx_http_process_request(r);
    
                return;
            }
    
            ......
    
            ngx_http_finalize_request(r, NGX_HTTP_BAD_REQUEST);
            return;
        }
    

    요청 헤드 를 반복 적 으로 분석 할 때 r - > requestlength。 pre - read 요청 체 코드 처리:
        preread = r->header_in->last - r->header_in->pos;
    
        if (preread) {
    
            /* there is the pre-read part of the request body */
    
            ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
                           "http client request body preread %uz", preread);
    
            out.buf = r->header_in;
            out.next = NULL;
    
            rc = ngx_http_request_body_filter(r, &out);
    
            if (rc != NGX_OK) {
                goto done;
            }
    
            r->request_length += preread - (r->header_in->last - r->header_in->pos);
            ......
        }
    

    r->request_length 누적 pre - read 요청 체 길이.처리 요청 체 코드:
    static ngx_int_t
    ngx_http_do_read_client_request_body(ngx_http_request_t *r)
    {
        ......
        for ( ;; ) {
            for ( ;; ) {
                ......
                n = c->recv(c, rb->buf->last, size);
    
                ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
                               "http client request body recv %z", n);
    
                if (n == NGX_AGAIN) {
                    break;
                }
    
                if (n == 0) {
                    ngx_log_error(NGX_LOG_INFO, c->log, 0,
                                  "client prematurely closed connection");
                }
    
                if (n == 0 || n == NGX_ERROR) {
                    c->error = 1;
                    return NGX_HTTP_BAD_REQUEST;
                }
    
                rb->buf->last += n;
                r->request_length += n;
                ......
            }
            ......
        }
        ......
    }
    

    r->request_length 누적 읽 기 요청 체 길이 입 니 다.
    $upstream_response_length
    변수 처리 코드:
    static ngx_int_t
    ngx_http_upstream_response_length_variable(ngx_http_request_t *r,
        ngx_http_variable_value_t *v, uintptr_t data)
    {
        u_char                     *p;
        size_t                      len;
        ngx_uint_t                  i;
        ngx_http_upstream_state_t  *state;
    
        v->valid = 1;
        v->no_cacheable = 0;
        v->not_found = 0;
    
        if (r->upstream_states == NULL || r->upstream_states->nelts == 0) {
            v->not_found = 1;
            return NGX_OK;
        }
    
        len = r->upstream_states->nelts * (NGX_OFF_T_LEN + 2);
    
        p = ngx_pnalloc(r->pool, len);
        if (p == NULL) {
            return NGX_ERROR;
        }
    
        v->data = p;
    
        i = 0;
        state = r->upstream_states->elts;
    
        for ( ;; ) {
            p = ngx_sprintf(p, "%O", state[i].response_length);
    
            if (++i == r->upstream_states->nelts) {
                break;
            }
    
            if (state[i].peer) {
                *p++ = ',';
                *p++ = ' ';
    
            } else {
                *p++ = ' ';
                *p++ = ':';
                *p++ = ' ';
    
                if (++i == r->upstream_states->nelts) {
                    break;
                }
    
                continue;
            }
        }
    
        v->len = p - v->data;
    
        return NGX_OK;
    }
    

    ngx_http_upstream_state_t 구조 체 코드:
    typedef struct {
        ngx_msec_t                       bl_time;
        ngx_uint_t                       bl_state;
    
        ngx_uint_t                       status;
        ngx_msec_t                       response_time;
        ngx_msec_t                       connect_time;
        ngx_msec_t                       header_time;
        off_t                            response_length;
    
        ngx_str_t                       *peer;
    } ngx_http_upstream_state_t;
    

    $upstream_response_length 는 바로 옮 겨 다 니 는 r - > upstreamstates (nginx 배열), ngx 꺼 내기http_upstream_state_t 중의 responselength。upstream 처리 과정 에서 백 엔 드 응답 정 보 를 r - > upstream - > state (ngx http upstream state t 형식 으로 r - > upstream states 배열 에 실제 저장) 에 저장 합 니 다.백 엔 드 서버 를 여러 번 요청 하면 백 엔 드 응답 정보 순 서 는 r - > upstream 에 저 장 됩 니 다.states 배열 에서 배열 의 마지막 요소, 즉 r - > upstream - > state 는 마지막 요청 백 엔 드 server 의 응답 정 보 를 저장 합 니 다.

    좋은 웹페이지 즐겨찾기