function serialize()

in kong/kong/pdk/log.lua [744:824]
71 lines of code
8 McCabe index (conditional complexity)

    function serialize(options)
      check_phase(PHASES_LOG)

      local ongx = (options or {}).ngx or ngx
      local okong = (options or {}).kong or kong

      local ctx = ongx.ctx
      local var = ongx.var

      local authenticated_entity
      if ctx.authenticated_credential ~= nil then
        authenticated_entity = {
          id = ctx.authenticated_credential.id,
          consumer_id = ctx.authenticated_credential.consumer_id
        }
      end

      local request_tls
      local request_tls_ver = ngx_ssl.get_tls1_version_str()
      if request_tls_ver then
        request_tls = {
          version = request_tls_ver,
          cipher = var.ssl_cipher,
          client_verify = ctx.CLIENT_VERIFY_OVERRIDE or var.ssl_client_verify,
        }
      end

      local request_uri = var.request_uri or ""

      local host_port = ctx.host_port or var.server_port

      local request_size = var.request_length
      if tonumber(request_size, 10) then
        request_size = tonumber(request_size, 10)
      end

      local response_size = var.bytes_sent
      if tonumber(response_size, 10) then
        response_size = tonumber(response_size, 10)
      end

      local upstream_uri = var.upstream_uri or ""
      if upstream_uri ~= "" and not find(upstream_uri, "?", nil, true) then
        if byte(ctx.request_uri or var.request_uri, -1) == QUESTION_MARK then
          upstream_uri = upstream_uri .. "?"
        elseif var.is_args == "?" then
          upstream_uri = upstream_uri .. "?" .. (var.args or "")
        end
      end

      return edit_result(ctx, {
        request = {
          uri = request_uri,
          url = var.scheme .. "://" .. var.host .. ":" .. host_port .. request_uri,
          querystring = okong.request.get_query(), 
          method = okong.request.get_method(), 
          headers = okong.request.get_headers(),
          size = request_size,
          tls = request_tls
        },
        upstream_uri = upstream_uri,
        response = {
          status = ongx.status,
          headers = ongx.resp.get_headers(),
          size = response_size,
        },
        tries = (ctx.balancer_data or {}).tries,
        latencies = {
          kong = (ctx.KONG_PROXY_LATENCY or ctx.KONG_RESPONSE_LATENCY or 0) +
                 (ctx.KONG_RECEIVE_TIME or 0),
          proxy = ctx.KONG_WAITING_TIME or -1,
          request = var.request_time * 1000
        },
        authenticated_entity = authenticated_entity,
        route = ctx.route,
        service = ctx.service,
        consumer = ctx.authenticated_consumer,
        client_ip = var.remote_addr,
        started_at = okong.request.get_start_time(),
      })
    end