src/request.rs - skywalking-php - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one or more
 // contributor license agreements.  See the NOTICE file distributed with
 // this work for additional information regarding copyright ownership.
 // The ASF licenses this file to You under the Apache License, Version 2.0
 // (the "License"); you may not use this file except in compliance with
 // the License.  You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 use crate::{
     component::COMPONENT_PHP_ID,
     context::RequestContext,
     module::{is_enable, SKYWALKING_VERSION},
     util::{catch_unwind_result, get_sapi_module_name, z_val_to_string},
 };
 use anyhow::{anyhow, Context};
 use dashmap::DashMap;
 use once_cell::sync::Lazy;
 use phper::{arrays::ZArr, eg, pg, sg, sys, values::ZVal};
 use skywalking::trace::{propagation::decoder::decode_propagation, span::AbstractSpan, tracer};
 use std::{
     panic::AssertUnwindSafe,
     ptr::null_mut,
     sync::atomic::{AtomicBool, AtomicPtr, Ordering},
 };
 use tracing::{error, instrument, trace, warn};
 use url::Url;

 #[instrument(skip_all)]
 pub fn init() {
     if !is_enable() {
         return;
     }
     if get_sapi_module_name().to_bytes() == b"fpm-fcgi" {
         if let Err(err) = catch_unwind_result(request_init_for_fpm) {
             error!(mode = "fpm", ?err, "request init failed");
         }
     }
 }

 #[instrument(skip_all)]
 pub fn shutdown() {
     if !is_enable() {
         return;
     }
     if get_sapi_module_name().to_bytes() == b"fpm-fcgi" {
         if let Err(err) = catch_unwind_result(request_shutdown_for_fpm) {
             error!(mode = "fpm", ?err, "request shutdown failed");
         }
     }
 }

 fn request_init_for_fpm() -> crate::Result<()> {
     jit_initialization();

     let server = get_page_request_server()?;

     let header = get_page_request_header(server);
     let url = get_page_request_url(server)?;
     let method = get_page_request_method(server);

     create_request_context(None, header.as_deref(), &method, &url)
 }

 fn request_shutdown_for_fpm() -> crate::Result<()> {
     let status_code = unsafe { sg!(sapi_headers).http_response_code };

     finish_request_context(None, status_code)
 }

 #[allow(clippy::useless_conversion)]
 fn jit_initialization() {
     unsafe {
         let jit_initialization: u8 = pg!(auto_globals_jit).into();
         if jit_initialization != 0 {
             let mut server = "_SERVER".to_string();
             sys::zend_is_auto_global_str(server.as_mut_ptr().cast(), server.len());
         }
     }
 }

 fn get_page_request_header(server: &ZArr) -> Option<String> {
     if *SKYWALKING_VERSION >= 8 {
         server
             .get("HTTP_SW8")
             .and_then(|sw| sw.as_z_str())
             .and_then(|zs| zs.to_str().ok())
             .map(|s| s.to_string())
     } else {
         None
     }
 }

 fn get_page_request_url(server: &ZArr) -> crate::Result<Url> {
     let scheme = if [Some("1"), Some("on")]
         .contains(&server.get("HTTPS").and_then(z_val_to_string).as_deref())
     {
         "https"
     } else {
         "http"
     };

     let addr = server
         .get("HTTP_HOST")
         .and_then(z_val_to_string)
         .or_else(|| {
             server
                 .get("SERVER_PORT")
                 .and_then(z_val_to_string)
                 .map(|port| format!("localhost:{}", port))
         })
         .unwrap_or_else(|| "unknown:0".to_string());

     let uri = server
         .get("REQUEST_URI")
         .and_then(z_val_to_string)
         .or_else(|| server.get("PHP_SELF").and_then(z_val_to_string))
         .or_else(|| server.get("SCRIPT_NAME").and_then(z_val_to_string))
         .unwrap_or_else(|| "/unknown".to_string());

     Ok(Url::parse(&format!("{}://{}{}", scheme, addr, uri))?)
 }

 fn get_page_request_method(server: &ZArr) -> String {
     server
         .get("REQUEST_METHOD")
         .and_then(z_val_to_string)
         .unwrap_or_else(|| "UNKNOWN".to_string())
 }

 fn get_page_request_server<'a>() -> anyhow::Result<&'a ZArr> {
     unsafe {
         let symbol_table = ZArr::from_mut_ptr(&mut eg!(symbol_table));
         let carrier = symbol_table
             .get("_SERVER")
             .and_then(|carrier| carrier.as_z_arr())
             .context("$_SERVER is null")?;
         Ok(carrier)
     }
 }

 pub const HACK_SWOOLE_ON_REQUEST_FUNCTION_NAME: &str =
     "skywalking_hack_swoole_on_request_please_do_not_use";

 /// Hold the response fd and status code kvs, because I dont't found that
 /// response has the status field, so I hook the response.status method, maybe
 /// there is a better way?
 pub static SWOOLE_RESPONSE_STATUS_MAP: Lazy<DashMap<i64, i32>> = Lazy::new(DashMap::new);

 pub static ORI_SWOOLE_ON_REQUEST: AtomicPtr<sys::zval> = AtomicPtr::new(null_mut());

 pub static IS_SWOOLE: AtomicBool = AtomicBool::new(false);

 /// The function is used by swoole plugin, to surround the callback of on
 /// request.
 pub fn skywalking_hack_swoole_on_request(args: &mut [ZVal]) -> phper::Result<ZVal> {
     let f = ORI_SWOOLE_ON_REQUEST.load(Ordering::Relaxed);
     if f.is_null() {
         error!("Origin swoole on request handler is null");
         return Ok(ZVal::from(()));
     }
     let f = unsafe { ZVal::from_mut_ptr(f) };

     let result = catch_unwind_result(AssertUnwindSafe(|| request_init_for_swoole(&mut args[0])));
     if let Err(err) = &result {
         error!(mode = "swoole", ?err, "request init failed");
     }

     let return_value = f.call(&mut *args);
     if let Err(err) = &return_value {
         error!(
             mode = "swoole",
             ?err,
             "Something wrong when call the origin on-request handler"
         );
     }

     if result.is_ok() {
         if let Err(err) = catch_unwind_result(AssertUnwindSafe(move || {
             request_shutdown_for_swoole(&mut args[1])
         })) {
             error!(mode = "swoole", ?err, "request shutdown failed");
         }
     }

     return_value
 }

 fn request_init_for_swoole(request: &mut ZVal) -> crate::Result<()> {
     let request = request.as_z_obj().context("swoole request isn't object")?;

     let fd = request
         .get_property("fd")
         .as_long()
         .context("swoole request fd not exists")?;

     let headers = request
         .get_property("header")
         .as_z_arr()
         .context("swoole request header not exists")?;

     let header = get_swoole_request_header(headers);

     let server = request
         .get_property("server")
         .as_z_arr()
         .context("swoole request server not exists")?;

     let method = get_swoole_request_method(server);
     let url = get_swoole_request_url(server, headers)?;

     create_request_context(Some(fd), header.as_deref(), &method, &url)
 }

 fn request_shutdown_for_swoole(response: &mut ZVal) -> crate::Result<()> {
     let response = response
         .as_mut_z_obj()
         .context("swoole response isn't object")?;

     let fd = response
         .get_mut_property("fd")
         .as_long()
         .context("swoole request fd not exists")?;

     finish_request_context(
         Some(fd),
         SWOOLE_RESPONSE_STATUS_MAP
             .remove(&fd)
             .map(|(_, status)| status)
             .unwrap_or(200),
     )
 }

 fn get_swoole_request_header(header: &ZArr) -> Option<String> {
     if *SKYWALKING_VERSION >= 8 {
         header
             .get("sw8")
             .and_then(|sw| sw.as_z_str())
             .and_then(|zs| zs.to_str().ok())
             .map(|s| s.to_string())
     } else {
         None
     }
 }

 fn get_swoole_request_url(server: &ZArr, headers: &ZArr) -> crate::Result<Url> {
     let addr = headers
         .get("host")
         .and_then(z_val_to_string)
         .or_else(|| {
             server
                 .get("server_port")
                 .and_then(z_val_to_string)
                 .map(|port| format!("localhost:{}", port))
         })
         .unwrap_or_else(|| "unknown:0".to_string());

     let uri = server
         .get("request_uri")
         .and_then(z_val_to_string)
         .unwrap_or_else(|| "/unknown".to_string());

     let query = server
         .get("query_string")
         .and_then(z_val_to_string)
         .map(|s| format!("?{}", s))
         .unwrap_or_default();

     Ok(Url::parse(&format!("http://{}{}{}", addr, uri, query))?)
 }

 fn get_swoole_request_method(server: &ZArr) -> String {
     server
         .get("request_method")
         .and_then(z_val_to_string)
         .unwrap_or_else(|| "UNKNOWN".to_string())
 }

 fn create_request_context(
     request_id: Option<i64>, header: Option<&str>, method: &str, url: &Url,
 ) -> crate::Result<()> {
     let propagation = header
         .map(decode_propagation)
         .transpose()
         .map_err(|e| anyhow!("decode propagation failed: {}", e))?;

     trace!("Propagation: {:?}", &propagation);

     let mut ctx = tracer::create_trace_context();

     let operation_name = format!("{}:{}", method, url.path());
     let mut span = match propagation {
         Some(propagation) => ctx.create_entry_span_with_propagation(&operation_name, &propagation),
         None => ctx.create_entry_span(&operation_name),
     };

     let mut span_object = span.span_object_mut();
     span_object.component_id = COMPONENT_PHP_ID;
     span_object.add_tag("url", url.to_string());
     span_object.add_tag("http.method", method);

     RequestContext::set_global(
         request_id,
         RequestContext {
             tracing_context: ctx,
             entry_span: span,
         },
     );

     Ok(())
 }

 fn finish_request_context(request_id: Option<i64>, status_code: i32) -> crate::Result<()> {
     let RequestContext {
         tracing_context,
         mut entry_span,
     } = RequestContext::remove_global(request_id).context("request context not exists")?;

     entry_span.add_tag("http.status_code", &status_code.to_string());
     if status_code >= 400 {
         entry_span.span_object_mut().is_error = true;
     }

     drop(entry_span);
     drop(tracing_context);

     Ok(())
 }
	// Licensed to the Apache Software Foundation (ASF) under one or more
	// contributor license agreements. See the NOTICE file distributed with
	// this work for additional information regarding copyright ownership.
	// The ASF licenses this file to You under the Apache License, Version 2.0
	// (the "License"); you may not use this file except in compliance with
	// the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	use crate::{
	component::COMPONENT_PHP_ID,
	context::RequestContext,
	module::{is_enable, SKYWALKING_VERSION},
	util::{catch_unwind_result, get_sapi_module_name, z_val_to_string},
	};
	use anyhow::{anyhow, Context};
	use dashmap::DashMap;
	use once_cell::sync::Lazy;
	use phper::{arrays::ZArr, eg, pg, sg, sys, values::ZVal};
	use skywalking::trace::{propagation::decoder::decode_propagation, span::AbstractSpan, tracer};
	use std::{
	panic::AssertUnwindSafe,
	ptr::null_mut,
	sync::atomic::{AtomicBool, AtomicPtr, Ordering},
	};
	use tracing::{error, instrument, trace, warn};
	use url::Url;

	#[instrument(skip_all)]
	pub fn init() {
	if !is_enable() {
	return;
	}
	if get_sapi_module_name().to_bytes() == b"fpm-fcgi" {
	if let Err(err) = catch_unwind_result(request_init_for_fpm) {
	error!(mode = "fpm", ?err, "request init failed");
	}
	}
	}

	#[instrument(skip_all)]
	pub fn shutdown() {
	if !is_enable() {
	return;
	}
	if get_sapi_module_name().to_bytes() == b"fpm-fcgi" {
	if let Err(err) = catch_unwind_result(request_shutdown_for_fpm) {
	error!(mode = "fpm", ?err, "request shutdown failed");
	}
	}
	}

	fn request_init_for_fpm() -> crate::Result<()> {
	jit_initialization();

	let server = get_page_request_server()?;

	let header = get_page_request_header(server);
	let url = get_page_request_url(server)?;
	let method = get_page_request_method(server);

	create_request_context(None, header.as_deref(), &method, &url)
	}

	fn request_shutdown_for_fpm() -> crate::Result<()> {
	let status_code = unsafe { sg!(sapi_headers).http_response_code };

	finish_request_context(None, status_code)
	}

	#[allow(clippy::useless_conversion)]
	fn jit_initialization() {
	unsafe {
	let jit_initialization: u8 = pg!(auto_globals_jit).into();
	if jit_initialization != 0 {
	let mut server = "_SERVER".to_string();
	sys::zend_is_auto_global_str(server.as_mut_ptr().cast(), server.len());
	}
	}
	}

	fn get_page_request_header(server: &ZArr) -> Option<String> {
	if *SKYWALKING_VERSION >= 8 {
	server
	.get("HTTP_SW8")
	.and_then(\|sw\| sw.as_z_str())
	.and_then(\|zs\| zs.to_str().ok())
	.map(\|s\| s.to_string())
	} else {
	None
	}
	}

	fn get_page_request_url(server: &ZArr) -> crate::Result<Url> {
	let scheme = if [Some("1"), Some("on")]
	.contains(&server.get("HTTPS").and_then(z_val_to_string).as_deref())
	{
	"https"
	} else {
	"http"
	};

	let addr = server
	.get("HTTP_HOST")
	.and_then(z_val_to_string)
	.or_else(\|\| {
	server
	.get("SERVER_PORT")
	.and_then(z_val_to_string)
	.map(\|port\| format!("localhost:{}", port))
	})
	.unwrap_or_else(\|\| "unknown:0".to_string());

	let uri = server
	.get("REQUEST_URI")
	.and_then(z_val_to_string)
	.or_else(\|\| server.get("PHP_SELF").and_then(z_val_to_string))
	.or_else(\|\| server.get("SCRIPT_NAME").and_then(z_val_to_string))
	.unwrap_or_else(\|\| "/unknown".to_string());

	Ok(Url::parse(&format!("{}://{}{}", scheme, addr, uri))?)
	}

	fn get_page_request_method(server: &ZArr) -> String {
	server
	.get("REQUEST_METHOD")
	.and_then(z_val_to_string)
	.unwrap_or_else(\|\| "UNKNOWN".to_string())
	}

	fn get_page_request_server<'a>() -> anyhow::Result<&'a ZArr> {
	unsafe {
	let symbol_table = ZArr::from_mut_ptr(&mut eg!(symbol_table));
	let carrier = symbol_table
	.get("_SERVER")
	.and_then(\|carrier\| carrier.as_z_arr())
	.context("$_SERVER is null")?;
	Ok(carrier)
	}
	}

	pub const HACK_SWOOLE_ON_REQUEST_FUNCTION_NAME: &str =
	"skywalking_hack_swoole_on_request_please_do_not_use";

	/// Hold the response fd and status code kvs, because I dont't found that
	/// response has the status field, so I hook the response.status method, maybe
	/// there is a better way?
	pub static SWOOLE_RESPONSE_STATUS_MAP: Lazy<DashMap<i64, i32>> = Lazy::new(DashMap::new);

	pub static ORI_SWOOLE_ON_REQUEST: AtomicPtr<sys::zval> = AtomicPtr::new(null_mut());

	pub static IS_SWOOLE: AtomicBool = AtomicBool::new(false);

	/// The function is used by swoole plugin, to surround the callback of on
	/// request.
	pub fn skywalking_hack_swoole_on_request(args: &mut [ZVal]) -> phper::Result<ZVal> {
	let f = ORI_SWOOLE_ON_REQUEST.load(Ordering::Relaxed);
	if f.is_null() {
	error!("Origin swoole on request handler is null");
	return Ok(ZVal::from(()));
	}
	let f = unsafe { ZVal::from_mut_ptr(f) };

	let result = catch_unwind_result(AssertUnwindSafe(\|\| request_init_for_swoole(&mut args[0])));
	if let Err(err) = &result {
	error!(mode = "swoole", ?err, "request init failed");
	}

	let return_value = f.call(&mut *args);
	if let Err(err) = &return_value {
	error!(
	mode = "swoole",
	?err,
	"Something wrong when call the origin on-request handler"
	);
	}

	if result.is_ok() {
	if let Err(err) = catch_unwind_result(AssertUnwindSafe(move \|\| {
	request_shutdown_for_swoole(&mut args[1])
	})) {
	error!(mode = "swoole", ?err, "request shutdown failed");
	}
	}

	return_value
	}

	fn request_init_for_swoole(request: &mut ZVal) -> crate::Result<()> {
	let request = request.as_z_obj().context("swoole request isn't object")?;

	let fd = request
	.get_property("fd")
	.as_long()
	.context("swoole request fd not exists")?;

	let headers = request
	.get_property("header")
	.as_z_arr()
	.context("swoole request header not exists")?;

	let header = get_swoole_request_header(headers);

	let server = request
	.get_property("server")
	.as_z_arr()
	.context("swoole request server not exists")?;

	let method = get_swoole_request_method(server);
	let url = get_swoole_request_url(server, headers)?;

	create_request_context(Some(fd), header.as_deref(), &method, &url)
	}

	fn request_shutdown_for_swoole(response: &mut ZVal) -> crate::Result<()> {
	let response = response
	.as_mut_z_obj()
	.context("swoole response isn't object")?;

	let fd = response
	.get_mut_property("fd")
	.as_long()
	.context("swoole request fd not exists")?;

	finish_request_context(
	Some(fd),
	SWOOLE_RESPONSE_STATUS_MAP
	.remove(&fd)
	.map(\|(_, status)\| status)
	.unwrap_or(200),
	)
	}

	fn get_swoole_request_header(header: &ZArr) -> Option<String> {
	if *SKYWALKING_VERSION >= 8 {
	header
	.get("sw8")
	.and_then(\|sw\| sw.as_z_str())
	.and_then(\|zs\| zs.to_str().ok())
	.map(\|s\| s.to_string())
	} else {
	None
	}
	}

	fn get_swoole_request_url(server: &ZArr, headers: &ZArr) -> crate::Result<Url> {
	let addr = headers
	.get("host")
	.and_then(z_val_to_string)
	.or_else(\|\| {
	server
	.get("server_port")
	.and_then(z_val_to_string)
	.map(\|port\| format!("localhost:{}", port))
	})
	.unwrap_or_else(\|\| "unknown:0".to_string());

	let uri = server
	.get("request_uri")
	.and_then(z_val_to_string)
	.unwrap_or_else(\|\| "/unknown".to_string());

	let query = server
	.get("query_string")
	.and_then(z_val_to_string)
	.map(\|s\| format!("?{}", s))
	.unwrap_or_default();

	Ok(Url::parse(&format!("http://{}{}{}", addr, uri, query))?)
	}

	fn get_swoole_request_method(server: &ZArr) -> String {
	server
	.get("request_method")
	.and_then(z_val_to_string)
	.unwrap_or_else(\|\| "UNKNOWN".to_string())
	}

	fn create_request_context(
	request_id: Option<i64>, header: Option<&str>, method: &str, url: &Url,
	) -> crate::Result<()> {
	let propagation = header
	.map(decode_propagation)
	.transpose()
	.map_err(\|e\| anyhow!("decode propagation failed: {}", e))?;

	trace!("Propagation: {:?}", &propagation);

	let mut ctx = tracer::create_trace_context();

	let operation_name = format!("{}:{}", method, url.path());
	let mut span = match propagation {
	Some(propagation) => ctx.create_entry_span_with_propagation(&operation_name, &propagation),
	None => ctx.create_entry_span(&operation_name),
	};

	let mut span_object = span.span_object_mut();
	span_object.component_id = COMPONENT_PHP_ID;
	span_object.add_tag("url", url.to_string());
	span_object.add_tag("http.method", method);

	RequestContext::set_global(
	request_id,
	RequestContext {
	tracing_context: ctx,
	entry_span: span,
	},
	);

	Ok(())
	}

	fn finish_request_context(request_id: Option<i64>, status_code: i32) -> crate::Result<()> {
	let RequestContext {
	tracing_context,
	mut entry_span,
	} = RequestContext::remove_global(request_id).context("request context not exists")?;

	entry_span.add_tag("http.status_code", &status_code.to_string());
	if status_code >= 400 {
	entry_span.span_object_mut().is_error = true;
	}

	drop(entry_span);
	drop(tracing_context);

	Ok(())
	}