From f678b576ca6d9529909e62c7f4b2a4f3218159e7 Mon Sep 17 00:00:00 2001 From: eeliu <27064129+eeliu@users.noreply.github.com> Date: Wed, 20 Sep 2023 13:38:03 +0800 Subject: [PATCH] Add clang format (#61) * add devcontainer * intro clang-format * add wheels --- .clang-format | 17 + .devcontainer/.gitignore | 1 + .devcontainer/Dockerfile | 36 + .devcontainer/devcontainer.json | 50 + .devcontainer/php.ini | 1949 +++++++++++++++++ .devcontainer/setup.sh | 0 .github/workflows/build-wheels.yml | 31 + .github/workflows/publish-pypitest.yml | 32 - .gitignore | 3 + common/CMakeLists.txt | 2 + common/include/common.h.in | 174 +- common/src/Cache/Chunk.cpp | 368 ++-- common/src/Cache/NodeTreeWriter.cpp | 10 +- common/src/Cache/SafeSharedState.cpp | 71 +- .../src/ConnectionPool/SpanConnectionPool.cpp | 120 +- common/src/ConnectionPool/TransLayer.cpp | 374 ++-- common/src/Context/ContextType.cpp | 10 +- common/src/NodePool/PoolManager.cpp | 250 +-- common/src/NodePool/PoolManager.h | 195 +- common/src/NodePool/TraceNode.cpp | 227 +- common/src/NodePool/TraceNode.h | 517 +++-- common/src/Util/Helper.cpp | 141 +- common/src/common.cpp | 810 +++---- common/test/test_chunk.cc | 87 +- common/test/test_common.cc | 258 ++- common/test/test_genUniqId.cc | 58 +- common/test/test_main.cpp | 13 +- common/test/test_node.cc | 580 +++-- common/test/test_node_pool.cc | 76 +- common/test/test_trans_layer.cc | 169 +- common/test/test_util.cc | 161 +- src/PHP/pinpoint_php.cpp | 753 +++---- 32 files changed, 4513 insertions(+), 3030 deletions(-) create mode 100644 .clang-format create mode 100644 .devcontainer/.gitignore create mode 100644 .devcontainer/Dockerfile create mode 100644 .devcontainer/devcontainer.json create mode 100644 .devcontainer/php.ini create mode 100644 .devcontainer/setup.sh create mode 100644 .github/workflows/build-wheels.yml delete mode 100644 .github/workflows/publish-pypitest.yml diff --git a/.clang-format b/.clang-format new file mode 100644 index 000000000..2947afef1 --- /dev/null +++ b/.clang-format @@ -0,0 +1,17 @@ +# Format Style Options - Created with Clang Power Tools +--- +BasedOnStyle: Google +AlignAfterOpenBracket: DontAlign +AllowAllArgumentsOnNextLine: false +AllowShortBlocksOnASingleLine: Always +BreakBeforeBraces: Linux +BreakStringLiterals: false +ColumnLimit: 150 +ContinuationIndentWidth: 2 +IncludeBlocks: Preserve +MaxEmptyLinesToKeep: 2 +ReflowComments: false +SortIncludes: false +SpaceAfterCStyleCast: true +UseTab: Always +... diff --git a/.devcontainer/.gitignore b/.devcontainer/.gitignore new file mode 100644 index 000000000..abe876bed --- /dev/null +++ b/.devcontainer/.gitignore @@ -0,0 +1 @@ +devcontainer.env \ No newline at end of file diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile new file mode 100644 index 000000000..6aef9aaa5 --- /dev/null +++ b/.devcontainer/Dockerfile @@ -0,0 +1,36 @@ +FROM ubuntu:20.04 +## install developmental env +ENV TZ=Asia/Shanghai +ENV LC_CTYPE=en_US.UTF-8 +ENV LC_ALL=en_US.UTF-8 +RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone +RUN apt update && apt install -y gcc g++ gdb pkg-config libxml2-dev libsqlite3-dev libcurl4-openssl-dev zlib1g-dev make cmake wget autoconf git clangd python3-pip +## enable php-7.4 +ENV PHP_VESION=php-7.4.33 +RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install +ENV PATH="$PATH:/opt/php/bin/:/opt/php/sbin/" +COPY php.ini /opt/ + +### Build php module +### curl +# RUN cd ~/${PHP_VESION}/ext/curl && phpize && ./configure && make -j && make install +### mysqli +# RUN cd ~/php-7.4.33/ext/mysqli && phpize && ./configure && make -j && make install +### pdo +# RUN cd ~/${PHP_VESION}/ext/pdo && phpize && ./configure && make -j && make install + +ENV PHP_VESION=php-5.6.30 +RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install + + +ENV PHP_VESION=php-5.5.38 +RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install + +ENV PHP_VESION=php-8.0.29 +RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install + +ENV PHP_VESION=php-8.1.21 +RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install + +ENV PHP_VESION=php-8.2.10 +RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install \ No newline at end of file diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json new file mode 100644 index 000000000..a5cefc255 --- /dev/null +++ b/.devcontainer/devcontainer.json @@ -0,0 +1,50 @@ +{ + "name": "PINPOINT php Dev", + "dockerFile": "Dockerfile", + "runArgs": [ + // "--user=vscode", + "--cap-add=SYS_PTRACE", + "--cap-add=NET_RAW", + "--cap-add=NET_ADMIN", + "--security-opt=seccomp=unconfined", + "--volume=${env:HOME}:${env:HOME}", + // "--volume=envoy-build:/build", + "--network=host", + // Uncomment next line if you have devcontainer.env + // "--env-file=.devcontainer/devcontainer.env" + ], + "containerEnv": { + "ENVOY_SRCDIR": "${containerWorkspaceFolder}", + }, + // "settings": { + // "terminal.integrated.shell.linux": "/bin/bash", + // "bazel.buildifierFixOnFormat": true, + // "clangd.path": "/opt/llvm/bin/clangd", + // "python.pythonPath": "/usr/bin/python3", + // "python.formatting.provider": "yapf", + // "python.formatting.yapfArgs": [ + // "--style=${workspaceFolder}/.style.yapf" + // ], + // "files.exclude": { + // "**/.clangd/**": true, + // "**/bazel-*/**": true + // }, + // "files.watcherExclude": { + // "**/.clangd/**": true, + // "**/bazel-*/**": true + // } + // }, + // "remoteUser": "vscode", + // "containerUser": "vscode", + "postCreateCommand": ".devcontainer/setup.sh", + "extensions": [ + "github.vscode-pull-request-github", + "zxh404.vscode-proto3", + "llvm-vs-code-extensions.vscode-clangd", + "vadimcn.vscode-lldb", + "webfreak.debug", + "ms-python.python", + "xaver.clang-format", + "zxh404.vscode-proto3" + ] +} \ No newline at end of file diff --git a/.devcontainer/php.ini b/.devcontainer/php.ini new file mode 100644 index 000000000..fdc7e869e --- /dev/null +++ b/.devcontainer/php.ini @@ -0,0 +1,1949 @@ +[PHP] + +;;;;;;;;;;;;;;;;;;; +; About php.ini ; +;;;;;;;;;;;;;;;;;;; +; PHP's initialization file, generally called php.ini, is responsible for +; configuring many of the aspects of PHP's behavior. + +; PHP attempts to find and load this configuration from a number of locations. +; The following is a summary of its search order: +; 1. SAPI module specific location. +; 2. The PHPRC environment variable. (As of PHP 5.2.0) +; 3. A number of predefined registry keys on Windows (As of PHP 5.2.0) +; 4. Current working directory (except CLI) +; 5. The web server's directory (for SAPI modules), or directory of PHP +; (otherwise in Windows) +; 6. The directory from the --with-config-file-path compile time option, or the +; Windows directory (usually C:\windows) +; See the PHP docs for more specific information. +; http://php.net/configuration.file + +; The syntax of the file is extremely simple. Whitespace and lines +; beginning with a semicolon are silently ignored (as you probably guessed). +; Section headers (e.g. [Foo]) are also silently ignored, even though +; they might mean something in the future. + +; Directives following the section heading [PATH=/www/mysite] only +; apply to PHP files in the /www/mysite directory. Directives +; following the section heading [HOST=www.example.com] only apply to +; PHP files served from www.example.com. Directives set in these +; special sections cannot be overridden by user-defined INI files or +; at runtime. Currently, [PATH=] and [HOST=] sections only work under +; CGI/FastCGI. +; http://php.net/ini.sections + +; Directives are specified using the following syntax: +; directive = value +; Directive names are *case sensitive* - foo=bar is different from FOO=bar. +; Directives are variables used to configure PHP or PHP extensions. +; There is no name validation. If PHP can't find an expected +; directive because it is not set or is mistyped, a default value will be used. + +; The value can be a string, a number, a PHP constant (e.g. E_ALL or M_PI), one +; of the INI constants (On, Off, True, False, Yes, No and None) or an expression +; (e.g. E_ALL & ~E_NOTICE), a quoted string ("bar"), or a reference to a +; previously set variable or directive (e.g. ${foo}) + +; Expressions in the INI file are limited to bitwise operators and parentheses: +; | bitwise OR +; ^ bitwise XOR +; & bitwise AND +; ~ bitwise NOT +; ! boolean NOT + +; Boolean flags can be turned on using the values 1, On, True or Yes. +; They can be turned off using the values 0, Off, False or No. + +; An empty string can be denoted by simply not writing anything after the equal +; sign, or by using the None keyword: + +; foo = ; sets foo to an empty string +; foo = None ; sets foo to an empty string +; foo = "None" ; sets foo to the string 'None' + +; If you use constants in your value, and these constants belong to a +; dynamically loaded extension (either a PHP extension or a Zend extension), +; you may only use these constants *after* the line that loads the extension. + +;;;;;;;;;;;;;;;;;;; +; About this file ; +;;;;;;;;;;;;;;;;;;; +; PHP comes packaged with two INI files. One that is recommended to be used +; in production environments and one that is recommended to be used in +; development environments. + +; php.ini-production contains settings which hold security, performance and +; best practices at its core. But please be aware, these settings may break +; compatibility with older or less security conscience applications. We +; recommending using the production ini in production and testing environments. + +; php.ini-development is very similar to its production variant, except it is +; much more verbose when it comes to errors. We recommend using the +; development version only in development environments, as errors shown to +; application users can inadvertently leak otherwise secure information. + +; This is the php.ini-development INI file. + +;;;;;;;;;;;;;;;;;;; +; Quick Reference ; +;;;;;;;;;;;;;;;;;;; +; The following are all the settings which are different in either the production +; or development versions of the INIs with respect to PHP's default behavior. +; Please see the actual settings later in the document for more details as to why +; we recommend these changes in PHP's behavior. + +; display_errors +; Default Value: On +; Development Value: On +; Production Value: Off + +; display_startup_errors +; Default Value: Off +; Development Value: On +; Production Value: Off + +; error_reporting +; Default Value: E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED +; Development Value: E_ALL +; Production Value: E_ALL & ~E_DEPRECATED & ~E_STRICT + +; log_errors +; Default Value: Off +; Development Value: On +; Production Value: On + +; max_input_time +; Default Value: -1 (Unlimited) +; Development Value: 60 (60 seconds) +; Production Value: 60 (60 seconds) + +; output_buffering +; Default Value: Off +; Development Value: 4096 +; Production Value: 4096 + +; register_argc_argv +; Default Value: On +; Development Value: Off +; Production Value: Off + +; request_order +; Default Value: None +; Development Value: "GP" +; Production Value: "GP" + +; session.gc_divisor +; Default Value: 100 +; Development Value: 1000 +; Production Value: 1000 + +; session.sid_bits_per_character +; Default Value: 4 +; Development Value: 5 +; Production Value: 5 + +; short_open_tag +; Default Value: On +; Development Value: Off +; Production Value: Off + +; variables_order +; Default Value: "EGPCS" +; Development Value: "GPCS" +; Production Value: "GPCS" + +;;;;;;;;;;;;;;;;;;;; +; php.ini Options ; +;;;;;;;;;;;;;;;;;;;; +; Name for user-defined php.ini (.htaccess) files. Default is ".user.ini" +;user_ini.filename = ".user.ini" + +; To disable this feature set this option to an empty value +;user_ini.filename = + +; TTL for user-defined php.ini files (time-to-live) in seconds. Default is 300 seconds (5 minutes) +;user_ini.cache_ttl = 300 + +;;;;;;;;;;;;;;;;;;;; +; Language Options ; +;;;;;;;;;;;;;;;;;;;; + +; Enable the PHP scripting language engine under Apache. +; http://php.net/engine +engine = On + +; This directive determines whether or not PHP will recognize code between +; tags as PHP source which should be processed as such. It is +; generally recommended that should be used and that this feature +; should be disabled, as enabling it may result in issues when generating XML +; documents, however this remains supported for backward compatibility reasons. +; Note that this directive does not control the would work. +; http://php.net/syntax-highlighting +;highlight.string = #DD0000 +;highlight.comment = #FF9900 +;highlight.keyword = #007700 +;highlight.default = #0000BB +;highlight.html = #000000 + +; If enabled, the request will be allowed to complete even if the user aborts +; the request. Consider enabling it if executing long requests, which may end up +; being interrupted by the user or a browser timing out. PHP's default behavior +; is to disable this feature. +; http://php.net/ignore-user-abort +;ignore_user_abort = On + +; Determines the size of the realpath cache to be used by PHP. This value should +; be increased on systems where PHP opens many files to reflect the quantity of +; the file operations performed. +; Note: if open_basedir is set, the cache is disabled +; http://php.net/realpath-cache-size +;realpath_cache_size = 4096k + +; Duration of time, in seconds for which to cache realpath information for a given +; file or directory. For systems with rarely changing files, consider increasing this +; value. +; http://php.net/realpath-cache-ttl +;realpath_cache_ttl = 120 + +; Enables or disables the circular reference collector. +; http://php.net/zend.enable-gc +zend.enable_gc = On + +; If enabled, scripts may be written in encodings that are incompatible with +; the scanner. CP936, Big5, CP949 and Shift_JIS are the examples of such +; encodings. To use this feature, mbstring extension must be enabled. +; Default: Off +;zend.multibyte = Off + +; Allows to set the default encoding for the scripts. This value will be used +; unless "declare(encoding=...)" directive appears at the top of the script. +; Only affects if zend.multibyte is set. +; Default: "" +;zend.script_encoding = + +; Allows to include or exclude arguments from stack traces generated for exceptions. +; In production, it is recommended to turn this setting on to prohibit the output +; of sensitive information in stack traces +; Default: Off +zend.exception_ignore_args = Off + +;;;;;;;;;;;;;;;;; +; Miscellaneous ; +;;;;;;;;;;;;;;;;; + +; Decides whether PHP may expose the fact that it is installed on the server +; (e.g. by adding its signature to the Web server header). It is no security +; threat in any way, but it makes it possible to determine whether you use PHP +; on your server or not. +; http://php.net/expose-php +expose_php = On + +;;;;;;;;;;;;;;;;;;; +; Resource Limits ; +;;;;;;;;;;;;;;;;;;; + +; Maximum execution time of each script, in seconds +; http://php.net/max-execution-time +; Note: This directive is hardcoded to 0 for the CLI SAPI +max_execution_time = 30 + +; Maximum amount of time each script may spend parsing request data. It's a good +; idea to limit this time on productions servers in order to eliminate unexpectedly +; long running scripts. +; Note: This directive is hardcoded to -1 for the CLI SAPI +; Default Value: -1 (Unlimited) +; Development Value: 60 (60 seconds) +; Production Value: 60 (60 seconds) +; http://php.net/max-input-time +max_input_time = 60 + +; Maximum input variable nesting level +; http://php.net/max-input-nesting-level +;max_input_nesting_level = 64 + +; How many GET/POST/COOKIE input variables may be accepted +;max_input_vars = 1000 + +; Maximum amount of memory a script may consume +; http://php.net/memory-limit +memory_limit = 128M + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +; Error handling and logging ; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +; This directive informs PHP of which errors, warnings and notices you would like +; it to take action for. The recommended way of setting values for this +; directive is through the use of the error level constants and bitwise +; operators. The error level constants are below here for convenience as well as +; some common settings and their meanings. +; By default, PHP is set to take action on all errors, notices and warnings EXCEPT +; those related to E_NOTICE and E_STRICT, which together cover best practices and +; recommended coding standards in PHP. For performance reasons, this is the +; recommend error reporting setting. Your production server shouldn't be wasting +; resources complaining about best practices and coding standards. That's what +; development servers and development settings are for. +; Note: The php.ini-development file has this setting as E_ALL. This +; means it pretty much reports everything which is exactly what you want during +; development and early testing. +; +; Error Level Constants: +; E_ALL - All errors and warnings (includes E_STRICT as of PHP 5.4.0) +; E_ERROR - fatal run-time errors +; E_RECOVERABLE_ERROR - almost fatal run-time errors +; E_WARNING - run-time warnings (non-fatal errors) +; E_PARSE - compile-time parse errors +; E_NOTICE - run-time notices (these are warnings which often result +; from a bug in your code, but it's possible that it was +; intentional (e.g., using an uninitialized variable and +; relying on the fact it is automatically initialized to an +; empty string) +; E_STRICT - run-time notices, enable to have PHP suggest changes +; to your code which will ensure the best interoperability +; and forward compatibility of your code +; E_CORE_ERROR - fatal errors that occur during PHP's initial startup +; E_CORE_WARNING - warnings (non-fatal errors) that occur during PHP's +; initial startup +; E_COMPILE_ERROR - fatal compile-time errors +; E_COMPILE_WARNING - compile-time warnings (non-fatal errors) +; E_USER_ERROR - user-generated error message +; E_USER_WARNING - user-generated warning message +; E_USER_NOTICE - user-generated notice message +; E_DEPRECATED - warn about code that will not work in future versions +; of PHP +; E_USER_DEPRECATED - user-generated deprecation warnings +; +; Common Values: +; E_ALL (Show all errors, warnings and notices including coding standards.) +; E_ALL & ~E_NOTICE (Show all errors, except for notices) +; E_ALL & ~E_NOTICE & ~E_STRICT (Show all errors, except for notices and coding standards warnings.) +; E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR (Show only errors) +; Default Value: E_ALL & ~E_NOTICE & ~E_STRICT & ~E_DEPRECATED +; Development Value: E_ALL +; Production Value: E_ALL & ~E_DEPRECATED & ~E_STRICT +; http://php.net/error-reporting +error_reporting = E_ALL + +; This directive controls whether or not and where PHP will output errors, +; notices and warnings too. Error output is very useful during development, but +; it could be very dangerous in production environments. Depending on the code +; which is triggering the error, sensitive information could potentially leak +; out of your application such as database usernames and passwords or worse. +; For production environments, we recommend logging errors rather than +; sending them to STDOUT. +; Possible Values: +; Off = Do not display any errors +; stderr = Display errors to STDERR (affects only CGI/CLI binaries!) +; On or stdout = Display errors to STDOUT +; Default Value: On +; Development Value: On +; Production Value: Off +; http://php.net/display-errors +display_errors = On + +; The display of errors which occur during PHP's startup sequence are handled +; separately from display_errors. PHP's default behavior is to suppress those +; errors from clients. Turning the display of startup errors on can be useful in +; debugging configuration problems. We strongly recommend you +; set this to 'off' for production servers. +; Default Value: Off +; Development Value: On +; Production Value: Off +; http://php.net/display-startup-errors +display_startup_errors = On + +; Besides displaying errors, PHP can also log errors to locations such as a +; server-specific log, STDERR, or a location specified by the error_log +; directive found below. While errors should not be displayed on productions +; servers they should still be monitored and logging is a great way to do that. +; Default Value: Off +; Development Value: On +; Production Value: On +; http://php.net/log-errors +log_errors = On + +; Set maximum length of log_errors. In error_log information about the source is +; added. The default is 1024 and 0 allows to not apply any maximum length at all. +; http://php.net/log-errors-max-len +log_errors_max_len = 1024 + +; Do not log repeated messages. Repeated errors must occur in same file on same +; line unless ignore_repeated_source is set true. +; http://php.net/ignore-repeated-errors +ignore_repeated_errors = Off + +; Ignore source of message when ignoring repeated messages. When this setting +; is On you will not log errors with repeated messages from different files or +; source lines. +; http://php.net/ignore-repeated-source +ignore_repeated_source = Off + +; If this parameter is set to Off, then memory leaks will not be shown (on +; stdout or in the log). This is only effective in a debug compile, and if +; error reporting includes E_WARNING in the allowed list +; http://php.net/report-memleaks +report_memleaks = On + +; This setting is on by default. +;report_zend_debug = 0 + +; Store the last error/warning message in $php_errormsg (boolean). Setting this value +; to On can assist in debugging and is appropriate for development servers. It should +; however be disabled on production servers. +; This directive is DEPRECATED. +; Default Value: Off +; Development Value: Off +; Production Value: Off +; http://php.net/track-errors +;track_errors = Off + +; Turn off normal error reporting and emit XML-RPC error XML +; http://php.net/xmlrpc-errors +;xmlrpc_errors = 0 + +; An XML-RPC faultCode +;xmlrpc_error_number = 0 + +; When PHP displays or logs an error, it has the capability of formatting the +; error message as HTML for easier reading. This directive controls whether +; the error message is formatted as HTML or not. +; Note: This directive is hardcoded to Off for the CLI SAPI +; http://php.net/html-errors +;html_errors = On + +; If html_errors is set to On *and* docref_root is not empty, then PHP +; produces clickable error messages that direct to a page describing the error +; or function causing the error in detail. +; You can download a copy of the PHP manual from http://php.net/docs +; and change docref_root to the base URL of your local copy including the +; leading '/'. You must also specify the file extension being used including +; the dot. PHP's default behavior is to leave these settings empty, in which +; case no links to documentation are generated. +; Note: Never use this feature for production boxes. +; http://php.net/docref-root +; Examples +;docref_root = "/phpmanual/" + +; http://php.net/docref-ext +;docref_ext = .html + +; String to output before an error message. PHP's default behavior is to leave +; this setting blank. +; http://php.net/error-prepend-string +; Example: +;error_prepend_string = "" + +; String to output after an error message. PHP's default behavior is to leave +; this setting blank. +; http://php.net/error-append-string +; Example: +;error_append_string = "" + +; Log errors to specified file. PHP's default behavior is to leave this value +; empty. +; http://php.net/error-log +; Example: +;error_log = php_errors.log +; Log errors to syslog (Event Log on Windows). +;error_log = syslog + +; The syslog ident is a string which is prepended to every message logged +; to syslog. Only used when error_log is set to syslog. +;syslog.ident = php + +; The syslog facility is used to specify what type of program is logging +; the message. Only used when error_log is set to syslog. +;syslog.facility = user + +; Set this to disable filtering control characters (the default). +; Some loggers only accept NVT-ASCII, others accept anything that's not +; control characters. If your logger accepts everything, then no filtering +; is needed at all. +; Allowed values are: +; ascii (all printable ASCII characters and NL) +; no-ctrl (all characters except control characters) +; all (all characters) +; raw (like "all", but messages are not split at newlines) +; http://php.net/syslog.filter +;syslog.filter = ascii + +;windows.show_crt_warning +; Default value: 0 +; Development value: 0 +; Production value: 0 + +;;;;;;;;;;;;;;;;; +; Data Handling ; +;;;;;;;;;;;;;;;;; + +; The separator used in PHP generated URLs to separate arguments. +; PHP's default setting is "&". +; http://php.net/arg-separator.output +; Example: +;arg_separator.output = "&" + +; List of separator(s) used by PHP to parse input URLs into variables. +; PHP's default setting is "&". +; NOTE: Every character in this directive is considered as separator! +; http://php.net/arg-separator.input +; Example: +;arg_separator.input = ";&" + +; This directive determines which super global arrays are registered when PHP +; starts up. G,P,C,E & S are abbreviations for the following respective super +; globals: GET, POST, COOKIE, ENV and SERVER. There is a performance penalty +; paid for the registration of these arrays and because ENV is not as commonly +; used as the others, ENV is not recommended on productions servers. You +; can still get access to the environment variables through getenv() should you +; need to. +; Default Value: "EGPCS" +; Development Value: "GPCS" +; Production Value: "GPCS"; +; http://php.net/variables-order +variables_order = "GPCS" + +; This directive determines which super global data (G,P & C) should be +; registered into the super global array REQUEST. If so, it also determines +; the order in which that data is registered. The values for this directive +; are specified in the same manner as the variables_order directive, +; EXCEPT one. Leaving this value empty will cause PHP to use the value set +; in the variables_order directive. It does not mean it will leave the super +; globals array REQUEST empty. +; Default Value: None +; Development Value: "GP" +; Production Value: "GP" +; http://php.net/request-order +request_order = "GP" + +; This directive determines whether PHP registers $argv & $argc each time it +; runs. $argv contains an array of all the arguments passed to PHP when a script +; is invoked. $argc contains an integer representing the number of arguments +; that were passed when the script was invoked. These arrays are extremely +; useful when running scripts from the command line. When this directive is +; enabled, registering these variables consumes CPU cycles and memory each time +; a script is executed. For performance reasons, this feature should be disabled +; on production servers. +; Note: This directive is hardcoded to On for the CLI SAPI +; Default Value: On +; Development Value: Off +; Production Value: Off +; http://php.net/register-argc-argv +register_argc_argv = Off + +; When enabled, the ENV, REQUEST and SERVER variables are created when they're +; first used (Just In Time) instead of when the script starts. If these +; variables are not used within a script, having this directive on will result +; in a performance gain. The PHP directive register_argc_argv must be disabled +; for this directive to have any effect. +; http://php.net/auto-globals-jit +auto_globals_jit = On + +; Whether PHP will read the POST data. +; This option is enabled by default. +; Most likely, you won't want to disable this option globally. It causes $_POST +; and $_FILES to always be empty; the only way you will be able to read the +; POST data will be through the php://input stream wrapper. This can be useful +; to proxy requests or to process the POST data in a memory efficient fashion. +; http://php.net/enable-post-data-reading +;enable_post_data_reading = Off + +; Maximum size of POST data that PHP will accept. +; Its value may be 0 to disable the limit. It is ignored if POST data reading +; is disabled through enable_post_data_reading. +; http://php.net/post-max-size +post_max_size = 8M + +; Automatically add files before PHP document. +; http://php.net/auto-prepend-file +auto_prepend_file = + +; Automatically add files after PHP document. +; http://php.net/auto-append-file +auto_append_file = + +; By default, PHP will output a media type using the Content-Type header. To +; disable this, simply set it to be empty. +; +; PHP's built-in default media type is set to text/html. +; http://php.net/default-mimetype +default_mimetype = "text/html" + +; PHP's default character set is set to UTF-8. +; http://php.net/default-charset +default_charset = "UTF-8" + +; PHP internal character encoding is set to empty. +; If empty, default_charset is used. +; http://php.net/internal-encoding +;internal_encoding = + +; PHP input character encoding is set to empty. +; If empty, default_charset is used. +; http://php.net/input-encoding +;input_encoding = + +; PHP output character encoding is set to empty. +; If empty, default_charset is used. +; See also output_buffer. +; http://php.net/output-encoding +;output_encoding = + +;;;;;;;;;;;;;;;;;;;;;;;;; +; Paths and Directories ; +;;;;;;;;;;;;;;;;;;;;;;;;; + +; UNIX: "/path1:/path2" +;include_path = ".:/php/includes" +; +; Windows: "\path1;\path2" +;include_path = ".;c:\php\includes" +; +; PHP's default setting for include_path is ".;/path/to/php/pear" +; http://php.net/include-path + +; The root of the PHP pages, used only if nonempty. +; if PHP was not compiled with FORCE_REDIRECT, you SHOULD set doc_root +; if you are running php as a CGI under any web server (other than IIS) +; see documentation for security issues. The alternate is to use the +; cgi.force_redirect configuration below +; http://php.net/doc-root +doc_root = + +; The directory under which PHP opens the script using /~username used only +; if nonempty. +; http://php.net/user-dir +user_dir = + +; Directory in which the loadable extensions (modules) reside. +; http://php.net/extension-dir +;extension_dir = "./" +; On windows: +;extension_dir = "ext" + +; Directory where the temporary files should be placed. +; Defaults to the system default (see sys_get_temp_dir) +;sys_temp_dir = "/tmp" + +; Whether or not to enable the dl() function. The dl() function does NOT work +; properly in multithreaded servers, such as IIS or Zeus, and is automatically +; disabled on them. +; http://php.net/enable-dl +enable_dl = Off + +; cgi.force_redirect is necessary to provide security running PHP as a CGI under +; most web servers. Left undefined, PHP turns this on by default. You can +; turn it off here AT YOUR OWN RISK +; **You CAN safely turn this off for IIS, in fact, you MUST.** +; http://php.net/cgi.force-redirect +;cgi.force_redirect = 1 + +; if cgi.nph is enabled it will force cgi to always sent Status: 200 with +; every request. PHP's default behavior is to disable this feature. +;cgi.nph = 1 + +; if cgi.force_redirect is turned on, and you are not running under Apache or Netscape +; (iPlanet) web servers, you MAY need to set an environment variable name that PHP +; will look for to know it is OK to continue execution. Setting this variable MAY +; cause security issues, KNOW WHAT YOU ARE DOING FIRST. +; http://php.net/cgi.redirect-status-env +;cgi.redirect_status_env = + +; cgi.fix_pathinfo provides *real* PATH_INFO/PATH_TRANSLATED support for CGI. PHP's +; previous behaviour was to set PATH_TRANSLATED to SCRIPT_FILENAME, and to not grok +; what PATH_INFO is. For more information on PATH_INFO, see the cgi specs. Setting +; this to 1 will cause PHP CGI to fix its paths to conform to the spec. A setting +; of zero causes PHP to behave as before. Default is 1. You should fix your scripts +; to use SCRIPT_FILENAME rather than PATH_TRANSLATED. +; http://php.net/cgi.fix-pathinfo +;cgi.fix_pathinfo=1 + +; if cgi.discard_path is enabled, the PHP CGI binary can safely be placed outside +; of the web tree and people will not be able to circumvent .htaccess security. +;cgi.discard_path=1 + +; FastCGI under IIS supports the ability to impersonate +; security tokens of the calling client. This allows IIS to define the +; security context that the request runs under. mod_fastcgi under Apache +; does not currently support this feature (03/17/2002) +; Set to 1 if running under IIS. Default is zero. +; http://php.net/fastcgi.impersonate +;fastcgi.impersonate = 1 + +; Disable logging through FastCGI connection. PHP's default behavior is to enable +; this feature. +;fastcgi.logging = 0 + +; cgi.rfc2616_headers configuration option tells PHP what type of headers to +; use when sending HTTP response code. If set to 0, PHP sends Status: header that +; is supported by Apache. When this option is set to 1, PHP will send +; RFC2616 compliant header. +; Default is zero. +; http://php.net/cgi.rfc2616-headers +;cgi.rfc2616_headers = 0 + +; cgi.check_shebang_line controls whether CGI PHP checks for line starting with #! +; (shebang) at the top of the running script. This line might be needed if the +; script support running both as stand-alone script and via PHP CGI<. PHP in CGI +; mode skips this line and ignores its content if this directive is turned on. +; http://php.net/cgi.check-shebang-line +;cgi.check_shebang_line=1 + +;;;;;;;;;;;;;;;; +; File Uploads ; +;;;;;;;;;;;;;;;; + +; Whether to allow HTTP file uploads. +; http://php.net/file-uploads +file_uploads = On + +; Temporary directory for HTTP uploaded files (will use system default if not +; specified). +; http://php.net/upload-tmp-dir +;upload_tmp_dir = + +; Maximum allowed size for uploaded files. +; http://php.net/upload-max-filesize +upload_max_filesize = 2M + +; Maximum number of files that can be uploaded via a single request +max_file_uploads = 20 + +;;;;;;;;;;;;;;;;;; +; Fopen wrappers ; +;;;;;;;;;;;;;;;;;; + +; Whether to allow the treatment of URLs (like http:// or ftp://) as files. +; http://php.net/allow-url-fopen +allow_url_fopen = On + +; Whether to allow include/require to open URLs (like http:// or ftp://) as files. +; http://php.net/allow-url-include +allow_url_include = Off + +; Define the anonymous ftp password (your email address). PHP's default setting +; for this is empty. +; http://php.net/from +;from="john@doe.com" + +; Define the User-Agent string. PHP's default setting for this is empty. +; http://php.net/user-agent +;user_agent="PHP" + +; Default timeout for socket based streams (seconds) +; http://php.net/default-socket-timeout +default_socket_timeout = 60 + +; If your scripts have to deal with files from Macintosh systems, +; or you are running on a Mac and need to deal with files from +; unix or win32 systems, setting this flag will cause PHP to +; automatically detect the EOL character in those files so that +; fgets() and file() will work regardless of the source of the file. +; http://php.net/auto-detect-line-endings +;auto_detect_line_endings = Off + +;;;;;;;;;;;;;;;;;;;;;; +; Dynamic Extensions ; +;;;;;;;;;;;;;;;;;;;;;; + +; If you wish to have an extension loaded automatically, use the following +; syntax: +; +; extension=modulename +; +; For example: +; +; extension=mysqli +; +; When the extension library to load is not located in the default extension +; directory, You may specify an absolute path to the library file: +; +; extension=/path/to/extension/mysqli.so +; +; Note : The syntax used in previous PHP versions ('extension=.so' and +; 'extension='php_.dll') is supported for legacy reasons and may be +; deprecated in a future PHP major version. So, when it is possible, please +; move to the new ('extension=) syntax. +; +; Notes for Windows environments : +; +; - Many DLL files are located in the extensions/ (PHP 4) or ext/ (PHP 5+) +; extension folders as well as the separate PECL DLL download (PHP 5+). +; Be sure to appropriately set the extension_dir directive. +; +; extension=bz2 +extension=curl +; extension=ffi +; extension=ftp +; extension=fileinfo +; extension=gd2 +; extension=gettext +; extension=gmp +; extension=intl +; extension=imap +; extension=ldap +; extension=mbstring +; extension=exif ; Must be after mbstring as it depends on it +; extension=mysqli +; extension=oci8_12c ; Use with Oracle Database 12c Instant Client +; extension=odbc +; extension=openssl +; extension=pdo_firebird +; extension=pdo_mysql +; extension=pdo_oci +; extension=pdo_odbc +; extension=pdo_pgsql +; extension=pdo_sqlite +; extension=pgsql +; extension=shmop + +zend_extension=opcache.so + +; The MIBS data available in the PHP distribution must be installed. +; See http://www.php.net/manual/en/snmp.installation.php +;extension=snmp + +;extension=soap +;extension=sockets +;extension=sodium +;extension=sqlite3 +;extension=tidy +;extension=xmlrpc +;extension=xsl + +;;;;;;;;;;;;;;;;;;; +; Module Settings ; +;;;;;;;;;;;;;;;;;;; + +[CLI Server] +; Whether the CLI web server uses ANSI color coding in its terminal output. +cli_server.color = On + +[Date] +; Defines the default timezone used by the date functions +; http://php.net/date.timezone +;date.timezone = + +; http://php.net/date.default-latitude +;date.default_latitude = 31.7667 + +; http://php.net/date.default-longitude +;date.default_longitude = 35.2333 + +; http://php.net/date.sunrise-zenith +;date.sunrise_zenith = 90.583333 + +; http://php.net/date.sunset-zenith +;date.sunset_zenith = 90.583333 + +[filter] +; http://php.net/filter.default +;filter.default = unsafe_raw + +; http://php.net/filter.default-flags +;filter.default_flags = + +[iconv] +; Use of this INI entry is deprecated, use global input_encoding instead. +; If empty, default_charset or input_encoding or iconv.input_encoding is used. +; The precedence is: default_charset < input_encoding < iconv.input_encoding +;iconv.input_encoding = + +; Use of this INI entry is deprecated, use global internal_encoding instead. +; If empty, default_charset or internal_encoding or iconv.internal_encoding is used. +; The precedence is: default_charset < internal_encoding < iconv.internal_encoding +;iconv.internal_encoding = + +; Use of this INI entry is deprecated, use global output_encoding instead. +; If empty, default_charset or output_encoding or iconv.output_encoding is used. +; The precedence is: default_charset < output_encoding < iconv.output_encoding +; To use an output encoding conversion, iconv's output handler must be set +; otherwise output encoding conversion cannot be performed. +;iconv.output_encoding = + +[imap] +; rsh/ssh logins are disabled by default. Use this INI entry if you want to +; enable them. Note that the IMAP library does not filter mailbox names before +; passing them to rsh/ssh command, thus passing untrusted data to this function +; with rsh/ssh enabled is insecure. +;imap.enable_insecure_rsh=0 + +[intl] +;intl.default_locale = +; This directive allows you to produce PHP errors when some error +; happens within intl functions. The value is the level of the error produced. +; Default is 0, which does not produce any errors. +;intl.error_level = E_WARNING +;intl.use_exceptions = 0 + +[sqlite3] +; Directory pointing to SQLite3 extensions +; http://php.net/sqlite3.extension-dir +;sqlite3.extension_dir = + +; SQLite defensive mode flag (only available from SQLite 3.26+) +; When the defensive flag is enabled, language features that allow ordinary +; SQL to deliberately corrupt the database file are disabled. This forbids +; writing directly to the schema, shadow tables (eg. FTS data tables), or +; the sqlite_dbpage virtual table. +; https://www.sqlite.org/c3ref/c_dbconfig_defensive.html +; (for older SQLite versions, this flag has no use) +;sqlite3.defensive = 1 + +[Pcre] +; PCRE library backtracking limit. +; http://php.net/pcre.backtrack-limit +;pcre.backtrack_limit=100000 + +; PCRE library recursion limit. +; Please note that if you set this value to a high number you may consume all +; the available process stack and eventually crash PHP (due to reaching the +; stack size limit imposed by the Operating System). +; http://php.net/pcre.recursion-limit +;pcre.recursion_limit=100000 + +; Enables or disables JIT compilation of patterns. This requires the PCRE +; library to be compiled with JIT support. +;pcre.jit=1 + +[Pdo] +; Whether to pool ODBC connections. Can be one of "strict", "relaxed" or "off" +; http://php.net/pdo-odbc.connection-pooling +;pdo_odbc.connection_pooling=strict + +;pdo_odbc.db2_instance_name + +[Pdo_mysql] +; Default socket name for local MySQL connects. If empty, uses the built-in +; MySQL defaults. +pdo_mysql.default_socket= + +[Phar] +; http://php.net/phar.readonly +;phar.readonly = On + +; http://php.net/phar.require-hash +;phar.require_hash = On + +;phar.cache_list = + +[mail function] +; For Win32 only. +; http://php.net/smtp +SMTP = localhost +; http://php.net/smtp-port +smtp_port = 25 + +; For Win32 only. +; http://php.net/sendmail-from +;sendmail_from = me@example.com + +; For Unix only. You may supply arguments as well (default: "sendmail -t -i"). +; http://php.net/sendmail-path +;sendmail_path = + +; Force the addition of the specified parameters to be passed as extra parameters +; to the sendmail binary. These parameters will always replace the value of +; the 5th parameter to mail(). +;mail.force_extra_parameters = + +; Add X-PHP-Originating-Script: that will include uid of the script followed by the filename +mail.add_x_header = Off + +; The path to a log file that will log all mail() calls. Log entries include +; the full path of the script, line number, To address and headers. +;mail.log = +; Log mail to syslog (Event Log on Windows). +;mail.log = syslog + +[ODBC] +; http://php.net/odbc.default-db +;odbc.default_db = Not yet implemented + +; http://php.net/odbc.default-user +;odbc.default_user = Not yet implemented + +; http://php.net/odbc.default-pw +;odbc.default_pw = Not yet implemented + +; Controls the ODBC cursor model. +; Default: SQL_CURSOR_STATIC (default). +;odbc.default_cursortype + +; Allow or prevent persistent links. +; http://php.net/odbc.allow-persistent +odbc.allow_persistent = On + +; Check that a connection is still valid before reuse. +; http://php.net/odbc.check-persistent +odbc.check_persistent = On + +; Maximum number of persistent links. -1 means no limit. +; http://php.net/odbc.max-persistent +odbc.max_persistent = -1 + +; Maximum number of links (persistent + non-persistent). -1 means no limit. +; http://php.net/odbc.max-links +odbc.max_links = -1 + +; Handling of LONG fields. Returns number of bytes to variables. 0 means +; passthru. +; http://php.net/odbc.defaultlrl +odbc.defaultlrl = 4096 + +; Handling of binary data. 0 means passthru, 1 return as is, 2 convert to char. +; See the documentation on odbc_binmode and odbc_longreadlen for an explanation +; of odbc.defaultlrl and odbc.defaultbinmode +; http://php.net/odbc.defaultbinmode +odbc.defaultbinmode = 1 + +[MySQLi] + +; Maximum number of persistent links. -1 means no limit. +; http://php.net/mysqli.max-persistent +mysqli.max_persistent = -1 + +; Allow accessing, from PHP's perspective, local files with LOAD DATA statements +; http://php.net/mysqli.allow_local_infile +;mysqli.allow_local_infile = On + +; Allow or prevent persistent links. +; http://php.net/mysqli.allow-persistent +mysqli.allow_persistent = On + +; Maximum number of links. -1 means no limit. +; http://php.net/mysqli.max-links +mysqli.max_links = -1 + +; Default port number for mysqli_connect(). If unset, mysqli_connect() will use +; the $MYSQL_TCP_PORT or the mysql-tcp entry in /etc/services or the +; compile-time value defined MYSQL_PORT (in that order). Win32 will only look +; at MYSQL_PORT. +; http://php.net/mysqli.default-port +mysqli.default_port = 3306 + +; Default socket name for local MySQL connects. If empty, uses the built-in +; MySQL defaults. +; http://php.net/mysqli.default-socket +mysqli.default_socket = + +; Default host for mysqli_connect() (doesn't apply in safe mode). +; http://php.net/mysqli.default-host +mysqli.default_host = + +; Default user for mysqli_connect() (doesn't apply in safe mode). +; http://php.net/mysqli.default-user +mysqli.default_user = + +; Default password for mysqli_connect() (doesn't apply in safe mode). +; Note that this is generally a *bad* idea to store passwords in this file. +; *Any* user with PHP access can run 'echo get_cfg_var("mysqli.default_pw") +; and reveal this password! And of course, any users with read access to this +; file will be able to reveal the password as well. +; http://php.net/mysqli.default-pw +mysqli.default_pw = + +; Allow or prevent reconnect +mysqli.reconnect = Off + +[mysqlnd] +; Enable / Disable collection of general statistics by mysqlnd which can be +; used to tune and monitor MySQL operations. +mysqlnd.collect_statistics = On + +; Enable / Disable collection of memory usage statistics by mysqlnd which can be +; used to tune and monitor MySQL operations. +mysqlnd.collect_memory_statistics = On + +; Records communication from all extensions using mysqlnd to the specified log +; file. +; http://php.net/mysqlnd.debug +;mysqlnd.debug = + +; Defines which queries will be logged. +;mysqlnd.log_mask = 0 + +; Default size of the mysqlnd memory pool, which is used by result sets. +;mysqlnd.mempool_default_size = 16000 + +; Size of a pre-allocated buffer used when sending commands to MySQL in bytes. +;mysqlnd.net_cmd_buffer_size = 2048 + +; Size of a pre-allocated buffer used for reading data sent by the server in +; bytes. +;mysqlnd.net_read_buffer_size = 32768 + +; Timeout for network requests in seconds. +;mysqlnd.net_read_timeout = 31536000 + +; SHA-256 Authentication Plugin related. File with the MySQL server public RSA +; key. +;mysqlnd.sha256_server_public_key = + +[OCI8] + +; Connection: Enables privileged connections using external +; credentials (OCI_SYSOPER, OCI_SYSDBA) +; http://php.net/oci8.privileged-connect +;oci8.privileged_connect = Off + +; Connection: The maximum number of persistent OCI8 connections per +; process. Using -1 means no limit. +; http://php.net/oci8.max-persistent +;oci8.max_persistent = -1 + +; Connection: The maximum number of seconds a process is allowed to +; maintain an idle persistent connection. Using -1 means idle +; persistent connections will be maintained forever. +; http://php.net/oci8.persistent-timeout +;oci8.persistent_timeout = -1 + +; Connection: The number of seconds that must pass before issuing a +; ping during oci_pconnect() to check the connection validity. When +; set to 0, each oci_pconnect() will cause a ping. Using -1 disables +; pings completely. +; http://php.net/oci8.ping-interval +;oci8.ping_interval = 60 + +; Connection: Set this to a user chosen connection class to be used +; for all pooled server requests with Oracle 11g Database Resident +; Connection Pooling (DRCP). To use DRCP, this value should be set to +; the same string for all web servers running the same application, +; the database pool must be configured, and the connection string must +; specify to use a pooled server. +;oci8.connection_class = + +; High Availability: Using On lets PHP receive Fast Application +; Notification (FAN) events generated when a database node fails. The +; database must also be configured to post FAN events. +;oci8.events = Off + +; Tuning: This option enables statement caching, and specifies how +; many statements to cache. Using 0 disables statement caching. +; http://php.net/oci8.statement-cache-size +;oci8.statement_cache_size = 20 + +; Tuning: Enables statement prefetching and sets the default number of +; rows that will be fetched automatically after statement execution. +; http://php.net/oci8.default-prefetch +;oci8.default_prefetch = 100 + +; Compatibility. Using On means oci_close() will not close +; oci_connect() and oci_new_connect() connections. +; http://php.net/oci8.old-oci-close-semantics +;oci8.old_oci_close_semantics = Off + +[PostgreSQL] +; Allow or prevent persistent links. +; http://php.net/pgsql.allow-persistent +pgsql.allow_persistent = On + +; Detect broken persistent links always with pg_pconnect(). +; Auto reset feature requires a little overheads. +; http://php.net/pgsql.auto-reset-persistent +pgsql.auto_reset_persistent = Off + +; Maximum number of persistent links. -1 means no limit. +; http://php.net/pgsql.max-persistent +pgsql.max_persistent = -1 + +; Maximum number of links (persistent+non persistent). -1 means no limit. +; http://php.net/pgsql.max-links +pgsql.max_links = -1 + +; Ignore PostgreSQL backends Notice message or not. +; Notice message logging require a little overheads. +; http://php.net/pgsql.ignore-notice +pgsql.ignore_notice = 0 + +; Log PostgreSQL backends Notice message or not. +; Unless pgsql.ignore_notice=0, module cannot log notice message. +; http://php.net/pgsql.log-notice +pgsql.log_notice = 0 + +[bcmath] +; Number of decimal digits for all bcmath functions. +; http://php.net/bcmath.scale +bcmath.scale = 0 + +[browscap] +; http://php.net/browscap +;browscap = extra/browscap.ini + +[Session] +; Handler used to store/retrieve data. +; http://php.net/session.save-handler +session.save_handler = files + +; Argument passed to save_handler. In the case of files, this is the path +; where data files are stored. Note: Windows users have to change this +; variable in order to use PHP's session functions. +; +; The path can be defined as: +; +; session.save_path = "N;/path" +; +; where N is an integer. Instead of storing all the session files in +; /path, what this will do is use subdirectories N-levels deep, and +; store the session data in those directories. This is useful if +; your OS has problems with many files in one directory, and is +; a more efficient layout for servers that handle many sessions. +; +; NOTE 1: PHP will not create this directory structure automatically. +; You can use the script in the ext/session dir for that purpose. +; NOTE 2: See the section on garbage collection below if you choose to +; use subdirectories for session storage +; +; The file storage module creates files using mode 600 by default. +; You can change that by using +; +; session.save_path = "N;MODE;/path" +; +; where MODE is the octal representation of the mode. Note that this +; does not overwrite the process's umask. +; http://php.net/session.save-path +;session.save_path = "/tmp" + +; Whether to use strict session mode. +; Strict session mode does not accept an uninitialized session ID, and +; regenerates the session ID if the browser sends an uninitialized session ID. +; Strict mode protects applications from session fixation via a session adoption +; vulnerability. It is disabled by default for maximum compatibility, but +; enabling it is encouraged. +; https://wiki.php.net/rfc/strict_sessions +session.use_strict_mode = 0 + +; Whether to use cookies. +; http://php.net/session.use-cookies +session.use_cookies = 1 + +; http://php.net/session.cookie-secure +;session.cookie_secure = + +; This option forces PHP to fetch and use a cookie for storing and maintaining +; the session id. We encourage this operation as it's very helpful in combating +; session hijacking when not specifying and managing your own session id. It is +; not the be-all and end-all of session hijacking defense, but it's a good start. +; http://php.net/session.use-only-cookies +session.use_only_cookies = 1 + +; Name of the session (used as cookie name). +; http://php.net/session.name +session.name = PHPSESSID + +; Initialize session on request startup. +; http://php.net/session.auto-start +session.auto_start = 0 + +; Lifetime in seconds of cookie or, if 0, until browser is restarted. +; http://php.net/session.cookie-lifetime +session.cookie_lifetime = 0 + +; The path for which the cookie is valid. +; http://php.net/session.cookie-path +session.cookie_path = / + +; The domain for which the cookie is valid. +; http://php.net/session.cookie-domain +session.cookie_domain = + +; Whether or not to add the httpOnly flag to the cookie, which makes it +; inaccessible to browser scripting languages such as JavaScript. +; http://php.net/session.cookie-httponly +session.cookie_httponly = + +; Add SameSite attribute to cookie to help mitigate Cross-Site Request Forgery (CSRF/XSRF) +; Current valid values are "Strict", "Lax" or "None". When using "None", +; make sure to include the quotes, as `none` is interpreted like `false` in ini files. +; https://tools.ietf.org/html/draft-west-first-party-cookies-07 +session.cookie_samesite = + +; Handler used to serialize data. php is the standard serializer of PHP. +; http://php.net/session.serialize-handler +session.serialize_handler = php + +; Defines the probability that the 'garbage collection' process is started on every +; session initialization. The probability is calculated by using gc_probability/gc_divisor, +; e.g. 1/100 means there is a 1% chance that the GC process starts on each request. +; Default Value: 1 +; Development Value: 1 +; Production Value: 1 +; http://php.net/session.gc-probability +session.gc_probability = 1 + +; Defines the probability that the 'garbage collection' process is started on every +; session initialization. The probability is calculated by using gc_probability/gc_divisor, +; e.g. 1/100 means there is a 1% chance that the GC process starts on each request. +; For high volume production servers, using a value of 1000 is a more efficient approach. +; Default Value: 100 +; Development Value: 1000 +; Production Value: 1000 +; http://php.net/session.gc-divisor +session.gc_divisor = 1000 + +; After this number of seconds, stored data will be seen as 'garbage' and +; cleaned up by the garbage collection process. +; http://php.net/session.gc-maxlifetime +session.gc_maxlifetime = 1440 + +; NOTE: If you are using the subdirectory option for storing session files +; (see session.save_path above), then garbage collection does *not* +; happen automatically. You will need to do your own garbage +; collection through a shell script, cron entry, or some other method. +; For example, the following script is the equivalent of setting +; session.gc_maxlifetime to 1440 (1440 seconds = 24 minutes): +; find /path/to/sessions -cmin +24 -type f | xargs rm + +; Check HTTP Referer to invalidate externally stored URLs containing ids. +; HTTP_REFERER has to contain this substring for the session to be +; considered as valid. +; http://php.net/session.referer-check +session.referer_check = + +; Set to {nocache,private,public,} to determine HTTP caching aspects +; or leave this empty to avoid sending anti-caching headers. +; http://php.net/session.cache-limiter +session.cache_limiter = nocache + +; Document expires after n minutes. +; http://php.net/session.cache-expire +session.cache_expire = 180 + +; trans sid support is disabled by default. +; Use of trans sid may risk your users' security. +; Use this option with caution. +; - User may send URL contains active session ID +; to other person via. email/irc/etc. +; - URL that contains active session ID may be stored +; in publicly accessible computer. +; - User may access your site with the same session ID +; always using URL stored in browser's history or bookmarks. +; http://php.net/session.use-trans-sid +session.use_trans_sid = 0 + +; Set session ID character length. This value could be between 22 to 256. +; Shorter length than default is supported only for compatibility reason. +; Users should use 32 or more chars. +; http://php.net/session.sid-length +; Default Value: 32 +; Development Value: 26 +; Production Value: 26 +session.sid_length = 26 + +; The URL rewriter will look for URLs in a defined set of HTML tags. +;
is special; if you include them here, the rewriter will +; add a hidden field with the info which is otherwise appended +; to URLs. tag's action attribute URL will not be modified +; unless it is specified. +; Note that all valid entries require a "=", even if no value follows. +; Default Value: "a=href,area=href,frame=src,form=" +; Development Value: "a=href,area=href,frame=src,form=" +; Production Value: "a=href,area=href,frame=src,form=" +; http://php.net/url-rewriter.tags +session.trans_sid_tags = "a=href,area=href,frame=src,form=" + +; URL rewriter does not rewrite absolute URLs by default. +; To enable rewrites for absolute paths, target hosts must be specified +; at RUNTIME. i.e. use ini_set() +; tags is special. PHP will check action attribute's URL regardless +; of session.trans_sid_tags setting. +; If no host is defined, HTTP_HOST will be used for allowed host. +; Example value: php.net,www.php.net,wiki.php.net +; Use "," for multiple hosts. No spaces are allowed. +; Default Value: "" +; Development Value: "" +; Production Value: "" +;session.trans_sid_hosts="" + +; Define how many bits are stored in each character when converting +; the binary hash data to something readable. +; Possible values: +; 4 (4 bits: 0-9, a-f) +; 5 (5 bits: 0-9, a-v) +; 6 (6 bits: 0-9, a-z, A-Z, "-", ",") +; Default Value: 4 +; Development Value: 5 +; Production Value: 5 +; http://php.net/session.hash-bits-per-character +session.sid_bits_per_character = 5 + +; Enable upload progress tracking in $_SESSION +; Default Value: On +; Development Value: On +; Production Value: On +; http://php.net/session.upload-progress.enabled +;session.upload_progress.enabled = On + +; Cleanup the progress information as soon as all POST data has been read +; (i.e. upload completed). +; Default Value: On +; Development Value: On +; Production Value: On +; http://php.net/session.upload-progress.cleanup +;session.upload_progress.cleanup = On + +; A prefix used for the upload progress key in $_SESSION +; Default Value: "upload_progress_" +; Development Value: "upload_progress_" +; Production Value: "upload_progress_" +; http://php.net/session.upload-progress.prefix +;session.upload_progress.prefix = "upload_progress_" + +; The index name (concatenated with the prefix) in $_SESSION +; containing the upload progress information +; Default Value: "PHP_SESSION_UPLOAD_PROGRESS" +; Development Value: "PHP_SESSION_UPLOAD_PROGRESS" +; Production Value: "PHP_SESSION_UPLOAD_PROGRESS" +; http://php.net/session.upload-progress.name +;session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS" + +; How frequently the upload progress should be updated. +; Given either in percentages (per-file), or in bytes +; Default Value: "1%" +; Development Value: "1%" +; Production Value: "1%" +; http://php.net/session.upload-progress.freq +;session.upload_progress.freq = "1%" + +; The minimum delay between updates, in seconds +; Default Value: 1 +; Development Value: 1 +; Production Value: 1 +; http://php.net/session.upload-progress.min-freq +;session.upload_progress.min_freq = "1" + +; Only write session data when session data is changed. Enabled by default. +; http://php.net/session.lazy-write +;session.lazy_write = On + +[Assertion] +; Switch whether to compile assertions at all (to have no overhead at run-time) +; -1: Do not compile at all +; 0: Jump over assertion at run-time +; 1: Execute assertions +; Changing from or to a negative value is only possible in php.ini! (For turning assertions on and off at run-time, see assert.active, when zend.assertions = 1) +; Default Value: 1 +; Development Value: 1 +; Production Value: -1 +; http://php.net/zend.assertions +zend.assertions = 1 + +; Assert(expr); active by default. +; http://php.net/assert.active +;assert.active = On + +; Throw an AssertionError on failed assertions +; http://php.net/assert.exception +;assert.exception = On + +; Issue a PHP warning for each failed assertion. (Overridden by assert.exception if active) +; http://php.net/assert.warning +;assert.warning = On + +; Don't bail out by default. +; http://php.net/assert.bail +;assert.bail = Off + +; User-function to be called if an assertion fails. +; http://php.net/assert.callback +;assert.callback = 0 + +; Eval the expression with current error_reporting(). Set to true if you want +; error_reporting(0) around the eval(). +; http://php.net/assert.quiet-eval +;assert.quiet_eval = 0 + +[COM] +; path to a file containing GUIDs, IIDs or filenames of files with TypeLibs +; http://php.net/com.typelib-file +;com.typelib_file = + +; allow Distributed-COM calls +; http://php.net/com.allow-dcom +;com.allow_dcom = true + +; autoregister constants of a component's typlib on com_load() +; http://php.net/com.autoregister-typelib +;com.autoregister_typelib = true + +; register constants casesensitive +; http://php.net/com.autoregister-casesensitive +;com.autoregister_casesensitive = false + +; show warnings on duplicate constant registrations +; http://php.net/com.autoregister-verbose +;com.autoregister_verbose = true + +; The default character set code-page to use when passing strings to and from COM objects. +; Default: system ANSI code page +;com.code_page= + +[mbstring] +; language for internal character representation. +; This affects mb_send_mail() and mbstring.detect_order. +; http://php.net/mbstring.language +;mbstring.language = Japanese + +; Use of this INI entry is deprecated, use global internal_encoding instead. +; internal/script encoding. +; Some encoding cannot work as internal encoding. (e.g. SJIS, BIG5, ISO-2022-*) +; If empty, default_charset or internal_encoding or iconv.internal_encoding is used. +; The precedence is: default_charset < internal_encoding < iconv.internal_encoding +;mbstring.internal_encoding = + +; Use of this INI entry is deprecated, use global input_encoding instead. +; http input encoding. +; mbstring.encoding_translation = On is needed to use this setting. +; If empty, default_charset or input_encoding or mbstring.input is used. +; The precedence is: default_charset < input_encoding < mbstring.http_input +; http://php.net/mbstring.http-input +;mbstring.http_input = + +; Use of this INI entry is deprecated, use global output_encoding instead. +; http output encoding. +; mb_output_handler must be registered as output buffer to function. +; If empty, default_charset or output_encoding or mbstring.http_output is used. +; The precedence is: default_charset < output_encoding < mbstring.http_output +; To use an output encoding conversion, mbstring's output handler must be set +; otherwise output encoding conversion cannot be performed. +; http://php.net/mbstring.http-output +;mbstring.http_output = + +; enable automatic encoding translation according to +; mbstring.internal_encoding setting. Input chars are +; converted to internal encoding by setting this to On. +; Note: Do _not_ use automatic encoding translation for +; portable libs/applications. +; http://php.net/mbstring.encoding-translation +;mbstring.encoding_translation = Off + +; automatic encoding detection order. +; "auto" detect order is changed according to mbstring.language +; http://php.net/mbstring.detect-order +;mbstring.detect_order = auto + +; substitute_character used when character cannot be converted +; one from another +; http://php.net/mbstring.substitute-character +;mbstring.substitute_character = none + +; overload(replace) single byte functions by mbstring functions. +; mail(), ereg(), etc are overloaded by mb_send_mail(), mb_ereg(), +; etc. Possible values are 0,1,2,4 or combination of them. +; For example, 7 for overload everything. +; 0: No overload +; 1: Overload mail() function +; 2: Overload str*() functions +; 4: Overload ereg*() functions +; http://php.net/mbstring.func-overload +;mbstring.func_overload = 0 + +; enable strict encoding detection. +; Default: Off +;mbstring.strict_detection = On + +; This directive specifies the regex pattern of content types for which mb_output_handler() +; is activated. +; Default: mbstring.http_output_conv_mimetype=^(text/|application/xhtml\+xml) +;mbstring.http_output_conv_mimetype= + +; This directive specifies maximum stack depth for mbstring regular expressions. It is similar +; to the pcre.recursion_limit for PCRE. +; Default: 100000 +;mbstring.regex_stack_limit=100000 + +; This directive specifies maximum retry count for mbstring regular expressions. It is similar +; to the pcre.backtrack_limit for PCRE. +; Default: 1000000 +;mbstring.regex_retry_limit=1000000 + +[gd] +; Tell the jpeg decode to ignore warnings and try to create +; a gd image. The warning will then be displayed as notices +; disabled by default +; http://php.net/gd.jpeg-ignore-warning +;gd.jpeg_ignore_warning = 1 + +[exif] +; Exif UNICODE user comments are handled as UCS-2BE/UCS-2LE and JIS as JIS. +; With mbstring support this will automatically be converted into the encoding +; given by corresponding encode setting. When empty mbstring.internal_encoding +; is used. For the decode settings you can distinguish between motorola and +; intel byte order. A decode setting cannot be empty. +; http://php.net/exif.encode-unicode +;exif.encode_unicode = ISO-8859-15 + +; http://php.net/exif.decode-unicode-motorola +;exif.decode_unicode_motorola = UCS-2BE + +; http://php.net/exif.decode-unicode-intel +;exif.decode_unicode_intel = UCS-2LE + +; http://php.net/exif.encode-jis +;exif.encode_jis = + +; http://php.net/exif.decode-jis-motorola +;exif.decode_jis_motorola = JIS + +; http://php.net/exif.decode-jis-intel +;exif.decode_jis_intel = JIS + +[Tidy] +; The path to a default tidy configuration file to use when using tidy +; http://php.net/tidy.default-config +;tidy.default_config = /usr/local/lib/php/default.tcfg + +; Should tidy clean and repair output automatically? +; WARNING: Do not use this option if you are generating non-html content +; such as dynamic images +; http://php.net/tidy.clean-output +tidy.clean_output = Off + +[soap] +; Enables or disables WSDL caching feature. +; http://php.net/soap.wsdl-cache-enabled +soap.wsdl_cache_enabled=1 + +; Sets the directory name where SOAP extension will put cache files. +; http://php.net/soap.wsdl-cache-dir +soap.wsdl_cache_dir="/tmp" + +; (time to live) Sets the number of second while cached file will be used +; instead of original one. +; http://php.net/soap.wsdl-cache-ttl +soap.wsdl_cache_ttl=86400 + +; Sets the size of the cache limit. (Max. number of WSDL files to cache) +soap.wsdl_cache_limit = 5 + +[sysvshm] +; A default size of the shared memory segment +;sysvshm.init_mem = 10000 + +[ldap] +; Sets the maximum number of open links or -1 for unlimited. +ldap.max_links = -1 + +[dba] +;dba.default_handler= + +[opcache] +; Determines if Zend OPCache is enabled +opcache.enable=1 + +; Determines if Zend OPCache is enabled for the CLI version of PHP +opcache.enable_cli=1 + +; The OPcache shared memory storage size. +opcache.memory_consumption=128 + +; The amount of memory for interned strings in Mbytes. +opcache.interned_strings_buffer=8 + +; The maximum number of keys (scripts) in the OPcache hash table. +; Only numbers between 200 and 1000000 are allowed. +;opcache.max_accelerated_files=10000 + +; The maximum percentage of "wasted" memory until a restart is scheduled. +;opcache.max_wasted_percentage=5 + +; When this directive is enabled, the OPcache appends the current working +; directory to the script key, thus eliminating possible collisions between +; files with the same name (basename). Disabling the directive improves +; performance, but may break existing applications. +opcache.use_cwd=1 + +; When disabled, you must reset the OPcache manually or restart the +; webserver for changes to the filesystem to take effect. +opcache.validate_timestamps=0 + +; How often (in seconds) to check file timestamps for changes to the shared +; memory storage allocation. ("1" means validate once per second, but only +; once per request. "0" means always validate) +;opcache.revalidate_freq=2 + +; Enables or disables file search in include_path optimization +;opcache.revalidate_path=0 + +; If disabled, all PHPDoc comments are dropped from the code to reduce the +; size of the optimized code. +;opcache.save_comments=1 + +; Allow file existence override (file_exists, etc.) performance feature. +;opcache.enable_file_override=0 + +; A bitmask, where each bit enables or disables the appropriate OPcache +; passes +;opcache.optimization_level=0x7FFFBFFF + +;opcache.dups_fix=0 + +; The location of the OPcache blacklist file (wildcards allowed). +; Each OPcache blacklist file is a text file that holds the names of files +; that should not be accelerated. The file format is to add each filename +; to a new line. The filename may be a full path or just a file prefix +; (i.e., /var/www/x blacklists all the files and directories in /var/www +; that start with 'x'). Line starting with a ; are ignored (comments). +;opcache.blacklist_filename= + +; Allows exclusion of large files from being cached. By default all files +; are cached. +;opcache.max_file_size=0 + +; Check the cache checksum each N requests. +; The default value of "0" means that the checks are disabled. +;opcache.consistency_checks=0 + +; How long to wait (in seconds) for a scheduled restart to begin if the cache +; is not being accessed. +;opcache.force_restart_timeout=180 + +; OPcache error_log file name. Empty string assumes "stderr". +opcache.error_log="" + +; All OPcache errors go to the Web server log. +; By default, only fatal errors (level 0) or errors (level 1) are logged. +; You can also enable warnings (level 2), info messages (level 3) or +; debug messages (level 4). +opcache.log_verbosity_level=4 + +; Preferred Shared Memory back-end. Leave empty and let the system decide. +;opcache.preferred_memory_model= + +; Protect the shared memory from unexpected writing during script execution. +; Useful for internal debugging only. +;opcache.protect_memory=0 + +; Allows calling OPcache API functions only from PHP scripts which path is +; started from specified string. The default "" means no restriction +;opcache.restrict_api= + +; Mapping base of shared memory segments (for Windows only). All the PHP +; processes have to map shared memory into the same address space. This +; directive allows to manually fix the "Unable to reattach to base address" +; errors. +;opcache.mmap_base= + +; Facilitates multiple OPcache instances per user (for Windows only). All PHP +; processes with the same cache ID and user share an OPcache instance. +;opcache.cache_id= + +; Enables and sets the second level cache directory. +; It should improve performance when SHM memory is full, at server restart or +; SHM reset. The default "" disables file based caching. +;opcache.file_cache= + +; Enables or disables opcode caching in shared memory. +;opcache.file_cache_only=0 + +; Enables or disables checksum validation when script loaded from file cache. +;opcache.file_cache_consistency_checks=1 + +; Implies opcache.file_cache_only=1 for a certain process that failed to +; reattach to the shared memory (for Windows only). Explicitly enabled file +; cache is required. +;opcache.file_cache_fallback=1 + +; Enables or disables copying of PHP code (text segment) into HUGE PAGES. +; This should improve performance, but requires appropriate OS configuration. +;opcache.huge_code_pages=0 + +; Validate cached file permissions. +;opcache.validate_permission=0 + +; Prevent name collisions in chroot'ed environment. +;opcache.validate_root=0 + +; If specified, it produces opcode dumps for debugging different stages of +; optimizations. +;opcache.opt_debug_level=0 + +; Specifies a PHP script that is going to be compiled and executed at server +; start-up. +; http://php.net/opcache.preload +;opcache.preload= + +; Preloading code as root is not allowed for security reasons. This directive +; facilitates to let the preloading to be run as another user. +; http://php.net/opcache.preload_user +;opcache.preload_user= + +; Prevents caching files that are less than this number of seconds old. It +; protects from caching of incompletely updated files. In case all file updates +; on your site are atomic, you may increase performance by setting it to "0". +;opcache.file_update_protection=2 + +; Absolute path used to store shared lockfiles (for *nix only). +;opcache.lockfile_path=/tmp + +[curl] +; A default value for the CURLOPT_CAINFO option. This is required to be an +; absolute path. +;curl.cainfo = + +[openssl] +; The location of a Certificate Authority (CA) file on the local filesystem +; to use when verifying the identity of SSL/TLS peers. Most users should +; not specify a value for this directive as PHP will attempt to use the +; OS-managed cert stores in its absence. If specified, this value may still +; be overridden on a per-stream basis via the "cafile" SSL stream context +; option. +;openssl.cafile= + +; If openssl.cafile is not specified or if the CA file is not found, the +; directory pointed to by openssl.capath is searched for a suitable +; certificate. This value must be a correctly hashed certificate directory. +; Most users should not specify a value for this directive as PHP will +; attempt to use the OS-managed cert stores in its absence. If specified, +; this value may still be overridden on a per-stream basis via the "capath" +; SSL stream context option. +;openssl.capath= + +[ffi] +; FFI API restriction. Possible values: +; "preload" - enabled in CLI scripts and preloaded files (default) +; "false" - always disabled +; "true" - always enabled +;ffi.enable=preload + +; List of headers files to preload, wildcard patterns allowed. +;ffi.preload= diff --git a/.devcontainer/setup.sh b/.devcontainer/setup.sh new file mode 100644 index 000000000..e69de29bb diff --git a/.github/workflows/build-wheels.yml b/.github/workflows/build-wheels.yml new file mode 100644 index 000000000..3079b688b --- /dev/null +++ b/.github/workflows/build-wheels.yml @@ -0,0 +1,31 @@ +name: build-wheels + +on: [workflow_dispatch] + +jobs: + build_wheels: + name: Build wheels on ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: [ubuntu-20.04, macOS-11] + + steps: + - uses: actions/checkout@v4 + + # Used to host cibuildwheel + - uses: actions/setup-python@v3 + + - name: Install cibuildwheel + run: python -m pip install cibuildwheel==2.16.0 + + - name: Build wheels + run: python -m cibuildwheel --output-dir wheelhouse + # to supply options, put them in 'env', like: + # env: + # CIBW_SOME_OPTION: value + + - uses: actions/upload-artifact@v3 + with: + name: pinpointPy + path: ./wheelhouse/*.whl \ No newline at end of file diff --git a/.github/workflows/publish-pypitest.yml b/.github/workflows/publish-pypitest.yml deleted file mode 100644 index a2de51fd6..000000000 --- a/.github/workflows/publish-pypitest.yml +++ /dev/null @@ -1,32 +0,0 @@ -name: publish-pypitest - -on: [workflow_dispatch] - -jobs: - pinpointPy-manylinux2014_x86_64: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - uses: actions/setup-python@v2 - with: - python-version: '3.8' - - uses: aminya/setup-cpp@v0.20.1 - with: - cmake: true - - name: Install dependencies - run: | - python -m pip install --upgrade pip - pip install twine wheel - - name: package - run: | - rm setup.py - ln -s setup_pypi_test.py setup.py - python setup.py sdist bdist_wheel - twine check dist/* - - name: Publish package to pypitest - uses: pypa/gh-action-pypi-publish@release/v1 - with: - user: __token__ - password: ${{ secrets.EELIUTEST }} - repository_url: https://test.pypi.org/legacy/ - # pinpointPy-macosx_10_15_x86_64.whl: \ No newline at end of file diff --git a/.gitignore b/.gitignore index 46f246d8b..3eee7055a 100644 --- a/.gitignore +++ b/.gitignore @@ -70,3 +70,6 @@ src/PHP/pinpoint_php.dep testapps/PHP/composer.phar collector-agent/collector-agent common/include/common.h +.cache +compile_commands.json +wheelhouse/ \ No newline at end of file diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index 0bf36810c..226643465 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -17,6 +17,8 @@ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNDEBUG -O2") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) +set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE INTERNAL "") add_definitions( -DAGENT_VERSION="${PROJECT_VERSION}") option (WITH_TEST_CASE "Enable Gtest" OFF) diff --git a/common/include/common.h.in b/common/include/common.h.in index 88d3209eb..69b2af722 100644 --- a/common/include/common.h.in +++ b/common/include/common.h.in @@ -34,78 +34,55 @@ #define IN_MSG_BUF_SIZE 4096 #define NAMING_SIZE 128 static const int RECONNECT_TIME_SEC = 5; -typedef enum -{ - RESPONSE_AGENT_INFO = 0, - REQ_UPDATE_SPAN = 1 -} MSG_TYPE; +typedef enum { RESPONSE_AGENT_INFO = 0, REQ_UPDATE_SPAN = 1 } MSG_TYPE; -typedef enum -{ - E_LOGGING = 0x1, - E_DISABLE_GIL = 0x2, // disable gil checking in python - E_UTEST = 0x4 +typedef enum { + E_LOGGING = 0x1, + E_DISABLE_GIL = 0x2, // disable gil checking in python + E_UTEST = 0x4 } AGENT_FLAG; -typedef enum -{ - E_INVALID_NODE = -1, - E_ROOT_NODE = 0 -} NodeID; +typedef enum { E_INVALID_NODE = -1, E_ROOT_NODE = 0 } NodeID; #pragma pack(1) -typedef struct -{ - uint32_t type; - uint32_t length; +typedef struct { + uint32_t type; + uint32_t length; } Header; #pragma pack() -typedef struct collector_agent_s -{ - uint64_t start_time; - char *appid; - char *appname; +typedef struct collector_agent_s { + uint64_t start_time; + char *appid; + char *appname; } CollectorAgentInfo; /// -typedef struct trace_store_layer -{ - void (*set_cur_trace_cb)(void *); - void *(*get_cur_trace_cb)(void); +typedef struct trace_store_layer { + void (*set_cur_trace_cb)(void *); + void *(*get_cur_trace_cb)(void); } TraceStoreLayer; #define LOG_SIZE 4096 #define MAX_ADDRESS_SIZE 256 typedef void (*VOID_FUNC)(void); -typedef struct pp_agent_s -{ - char co_host[MAX_ADDRESS_SIZE]; // tcp:ip:port should support dns - long timeout_ms; // always be 0 - long trace_limit; // change to long as python need long - int agent_type; - uint8_t inter_flag; - VOID_FUNC get_read_lock; - VOID_FUNC get_write_lock; - VOID_FUNC release_lock; +typedef struct pp_agent_s { + char co_host[MAX_ADDRESS_SIZE]; // tcp:ip:port should support dns + long timeout_ms; // always be 0 + long trace_limit; // change to long as python need long + int agent_type; + uint8_t inter_flag; + VOID_FUNC get_read_lock; + VOID_FUNC get_write_lock; + VOID_FUNC release_lock; } PPAgentT; -typedef enum -{ - E_OFFLINE = 0x1, - E_TRACE_PASS = 0x2, - E_TRACE_BLOCK = 0x4, - E_READY = 0x8 -} E_AGENT_STATUS; +typedef enum { E_OFFLINE = 0x1, E_TRACE_PASS = 0x2, E_TRACE_BLOCK = 0x4, E_READY = 0x8 } E_AGENT_STATUS; /** * @brief at present only root checking */ -typedef enum -{ - E_LOC_CURRENT = 0x0, - E_LOC_ROOT = 0x1 -} E_NODE_LOC; +typedef enum { E_LOC_CURRENT = 0x0, E_LOC_ROOT = 0x1 } E_NODE_LOC; #define PINPOINT_C_AGENT_API_VERSION "@PROJECT_VERSION@" @@ -121,31 +98,30 @@ typedef enum * - add tls */ #ifdef __cplusplus -extern "C" -{ +extern "C" { #endif - extern PPAgentT global_agent_info; +extern PPAgentT global_agent_info; - /** +/** * @brief [tls] * pinpoint_get_per_thread_id and pinpoint_update_per_thread_id are paired API * pinpoint_get_per_thread_id get the current trace-id of current thread * pinpoint_update_per_thread_id update(stores) the current trace-id for pinpoint_get_per_thread_id * @return NodeID */ - NodeID pinpoint_get_per_thread_id(void); - void pinpoint_update_per_thread_id(NodeID id); +NodeID pinpoint_get_per_thread_id(void); +void pinpoint_update_per_thread_id(NodeID id); - /** +/** * @brief [tls] start a trace (span) from parentId. if current span is empty, create a span or else create a spanevent * * @param parentId * @return -1: failed new traceId related to parentId (caller [parentId] -> callee [NodeID] ) */ - NodeID pinpoint_start_trace(NodeID parentId); +NodeID pinpoint_start_trace(NodeID parentId); - /** +/** * @brief [tls] V1 support trace with optional config * Not support on root traceNode * @param parentId @@ -156,67 +132,67 @@ extern "C" * "TraceOnlyException" // only trace exception( only report when call pinpoint_add_exception) * @return NodeID */ - NodeID pinpoint_start_traceV1(NodeID parentId, const char *opt, ...); +NodeID pinpoint_start_traceV1(NodeID parentId, const char *opt, ...); - void pinpoint_add_exception(NodeID, const char *exp); +void pinpoint_add_exception(NodeID, const char *exp); - /**[tls] +/**[tls] * the same as pinpoint_start_trace. BUT, end a span or a spanevent * Note: pinpoint_end_trace is thread safe, but you should avoid to call it in the multi-thread, it may send duplicate trace span * @return NodeID is parent node id */ - NodeID pinpoint_end_trace(NodeID); +NodeID pinpoint_end_trace(NodeID); - /** +/** * @brief wake a finished trace: this trace get a new startime, so it could be profile again. the end_trace will update the ["e"] by cumulative time (NOTE: root trace not supported) * * @param traceId * @return int 0 if success, -1 if failed */ - int pinpoint_wake_trace(NodeID traceId); +int pinpoint_wake_trace(NodeID traceId); - /** +/** * check id->traceNode is root * @param * @return 1: is root; 0: not root node;-1: A wrong id */ - int pinpoint_trace_is_root(NodeID); +int pinpoint_trace_is_root(NodeID); - /** +/** * force end current trace, only called when callstack leaked * @return int 0 : means oK * -1: exception found, check the log */ - int pinpoint_force_end_trace(NodeID, int32_t timeout); +int pinpoint_force_end_trace(NodeID, int32_t timeout); - /** +/** * [tls] pinpoint_add_clues, append a value into span[key] * @param key must be a string * @param value key must be a string */ - void pinpoint_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); - /** +void pinpoint_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); +/** * [tls] pinpoint_add_clues, add a key-value into span. span[key]=value * @param key must be a string * @param value key must be a string */ - void pinpoint_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); - /** +void pinpoint_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); +/** * [tls] add a key value into current trace. IF the trace is end, all data(key-value) will be free * @param key * @param value */ - void pinpoint_set_context_key(NodeID _id, const char *key, const char *value); - /** +void pinpoint_set_context_key(NodeID _id, const char *key, const char *value); +/** * [tls] get the corresponding value with key(in current trace) * @param size copy into pbuf, not include '\0' * @return */ - int pinpoint_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size); +int pinpoint_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size); - void pinpoint_set_context_long(NodeID _id, const char *key, long); +void pinpoint_set_context_long(NodeID _id, const char *key, long); - /** +/** * @brief the value is a long type * * @param _id node id @@ -224,15 +200,15 @@ extern "C" * @return int 1: failed * 0: success */ - int pinpoint_get_context_long(NodeID _id, const char *key, long *); - /** +int pinpoint_get_context_long(NodeID _id, const char *key, long *); +/** * [tls] if tracelimit enable, check current trace state, * @param timestamp * @return 0, sampled or else, not sampled */ - int check_tracelimit(int64_t); +int check_tracelimit(int64_t); - /** +/** * @brief [tls] setting current trace status typedef enum { E_OFFLINE = 0x1, @@ -244,45 +220,45 @@ extern "C" * @param status * @return int last status */ - uint64_t mark_current_trace_status(NodeID _id, int status); +uint64_t mark_current_trace_status(NodeID _id, int status); - /** +/** * [tls] get an unique auto-increment id * NOTE: implement by shared memory, only valid in current host. * @return */ - int64_t generate_unique_id(void); +int64_t generate_unique_id(void); - /** +/** * [tls] get the start time of collector-agent.Use to generate transactionID * @return */ - uint64_t pinpoint_start_time(void); +uint64_t pinpoint_start_time(void); - /** +/** * mark current span with error * @param msg * @param error_filename * @param error_lineno */ - void catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno); - typedef void (*log_msg_cb)(char *); - void register_error_cb(log_msg_cb error_cb); +void catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno); +typedef void (*log_msg_cb)(char *); +void register_error_cb(log_msg_cb error_cb); - /** +/** * @brief for test-case: not send span to collector-agent, pass to handler * not tls * @param handler */ - void register_span_handler(void (*handler)(const char *)); +void register_span_handler(void (*handler)(const char *)); - void pp_trace(const char *format, ...); - /** +void pp_trace(const char *format, ...); +/** * NOTE: only for testcase */ - void reset_unique_id(void); - const char *pinpoint_agent_version(); - void show_status(void); +void reset_unique_id(void); +const char *pinpoint_agent_version(); +void show_status(void); #ifdef __cplusplus } #endif diff --git a/common/src/Cache/Chunk.cpp b/common/src/Cache/Chunk.cpp index f7ace8071..9eedbac81 100644 --- a/common/src/Cache/Chunk.cpp +++ b/common/src/Cache/Chunk.cpp @@ -20,278 +20,224 @@ * Author: eeliu */ #include "Chunk.h" -namespace Cache{ - +namespace Cache +{ int Chunks::copyDataIntoReadyCK(const void* data, uint32_t length) { - if (ready_cks.empty()) - { - return length; - } - - Chunk* ck = ready_cks.back(); - - char* p_ck_r = &ck->data[ck->r_ofs]; - uint32_t capacity = ck->block_size - ck->r_ofs; - if (capacity >= length) - { - memcpy(p_ck_r, data, length); - ck->r_ofs += length; - length = 0; - } - else if (capacity > 0) // capacity < length - { // current ck is full - memcpy(p_ck_r, data, capacity); - length -= capacity; - ck->r_ofs += capacity; - } - - return length; + if (ready_cks.empty()) { return length; } + + Chunk* ck = ready_cks.back(); + + char* p_ck_r = &ck->data[ck->r_ofs]; + uint32_t capacity = ck->block_size - ck->r_ofs; + if (capacity >= length) { + memcpy(p_ck_r, data, length); + ck->r_ofs += length; + length = 0; + } else if (capacity > 0) // capacity < length + { // current ck is full + memcpy(p_ck_r, data, capacity); + length -= capacity; + ck->r_ofs += capacity; + } + + return length; } -int Chunks::copyDataIntoFreeCK(const void*data, uint32_t length) +int Chunks::copyDataIntoFreeCK(const void* data, uint32_t length) { - if (this->free_cks.empty()) - { - return length; - } + if (this->free_cks.empty()) { return length; } - iter = this->free_cks.begin(); + iter = this->free_cks.begin(); - while (iter != this->free_cks.end() && length >0 ) - { - Chunk* ck = *iter; - iter++; - char* f_buf_start = &ck->data[ck->r_ofs]; - uint32_t ck_capacity = ck->block_size - ck->r_ofs; - if (ck_capacity >= length) - { - // current data task is done - memcpy(f_buf_start, data, length); - ck->r_ofs += length; - length = 0; - - } - else if (ck_capacity > 0) //ck_capacity < length - { - memcpy(f_buf_start, data, ck_capacity); - length -= ck_capacity; - data = (const char*) data + ck_capacity; - ck->r_ofs += ck_capacity; - } - - this->ck_free_ck_capacity -= ck->block_size; - // remove free in flist - this->free_cks.pop_front(); - // append free into rlist_end - this->ready_cks.push_back(ck); + while (iter != this->free_cks.end() && length > 0) { + Chunk* ck = *iter; + iter++; + char* f_buf_start = &ck->data[ck->r_ofs]; + uint32_t ck_capacity = ck->block_size - ck->r_ofs; + if (ck_capacity >= length) { + // current data task is done + memcpy(f_buf_start, data, length); + ck->r_ofs += length; + length = 0; + } else if (ck_capacity > 0) //ck_capacity < length + { + memcpy(f_buf_start, data, ck_capacity); + length -= ck_capacity; + data = (const char*) data + ck_capacity; + ck->r_ofs += ck_capacity; } - return length; + this->ck_free_ck_capacity -= ck->block_size; + // remove free in flist + this->free_cks.pop_front(); + // append free into rlist_end + this->ready_cks.push_back(ck); + } + + return length; } uint32_t Chunks::ck_ceil_to_k(uint32_t i) { - if (i < threshold) - { - return threshold; - } + if (i < threshold) { return threshold; } - uint32_t k = 0x80000000; - while (k && !(k & i)) - { - k >>= 1; - } - return k << 1; + uint32_t k = 0x80000000; + while (k && !(k & i)) { k >>= 1; } + return k << 1; } int Chunks::copyDataIntoNewChunk(const void* data, uint32_t length) { - int mem_size = ck_ceil_to_k(sizeof(Chunk) + length); - - // new a chunk - Chunk* ck = (Chunk*) malloc(mem_size); - if (ck == NULL) - { - return -1; - } - ck->block_size = mem_size - sizeof(Chunk); - memcpy(&ck->data[0], data, length); - ck->r_ofs = length; - ck->l_ofs = 0; - /// insert into ready list - this->ready_cks.push_back(ck); - this->ck_alloc_size += mem_size; - return 0; + int mem_size = ck_ceil_to_k(sizeof(Chunk) + length); + + // new a chunk + Chunk* ck = (Chunk*) malloc(mem_size); + if (ck == NULL) { return -1; } + ck->block_size = mem_size - sizeof(Chunk); + memcpy(&ck->data[0], data, length); + ck->r_ofs = length; + ck->l_ofs = 0; + /// insert into ready list + this->ready_cks.push_back(ck); + this->ck_alloc_size += mem_size; + return 0; } void Chunks::reduceFreeCK() { - if (!this->free_cks.empty()) - { - Chunk* c = *this->free_cks.begin(); - this->free_cks.pop_front(); - this->ck_alloc_size -= (c->block_size + sizeof(Chunk) ); - this->ck_free_ck_capacity -= c->block_size; - free(c); - } + if (!this->free_cks.empty()) { + Chunk* c = *this->free_cks.begin(); + this->free_cks.pop_front(); + this->ck_alloc_size -= (c->block_size + sizeof(Chunk)); + this->ck_free_ck_capacity -= c->block_size; + free(c); + } } void Chunks::checkWaterLevel() { - while (this->c_resident_size < this->ck_alloc_size - && !this->free_cks.empty()) - { - this->reduceFreeCK(); - } + while (this->c_resident_size < this->ck_alloc_size && !this->free_cks.empty()) { this->reduceFreeCK(); } } -uint32_t Chunks::getAllocSize() const -{ - return this->ck_alloc_size; -} +uint32_t Chunks::getAllocSize() const { return this->ck_alloc_size; } -Chunks::Chunks(uint32_t max_size, uint32_t resident_size) : - c_resident_size(resident_size),c_max_size(max_size),threshold(1024) +Chunks::Chunks(uint32_t max_size, uint32_t resident_size) : c_resident_size(resident_size), c_max_size(max_size), threshold(1024) { - this->ck_alloc_size = 0; - this->ck_free_ck_capacity = 0; - if(max_size < resident_size) - throw std::invalid_argument("chunks: max_size must bigger then resident_size"); + this->ck_alloc_size = 0; + this->ck_free_ck_capacity = 0; + if (max_size < resident_size) throw std::invalid_argument("chunks: max_size must bigger then resident_size"); } Chunks::~Chunks() { - while (!this->ready_cks.empty()) - { - Chunk* c = this->ready_cks.front(); - free(c); - ready_cks.pop_front(); - } - - while (!this->free_cks.empty()) - { - Chunk* c = *this->free_cks.begin(); - free(c); - free_cks.pop_front(); - } - this->ck_free_ck_capacity = 0; + while (!this->ready_cks.empty()) { + Chunk* c = this->ready_cks.front(); + free(c); + ready_cks.pop_front(); + } + + while (!this->free_cks.empty()) { + Chunk* c = *this->free_cks.begin(); + free(c); + free_cks.pop_front(); + } + this->ck_free_ck_capacity = 0; } bool Chunks::useExistingChunk(uint32_t length) const { - Chunk * c = nullptr; - if(!this->ready_cks.empty()) - { - c = this->ready_cks.back(); - uint32_t availiable = c->block_size - c->r_ofs ; - if (availiable < length){ - return false; - }else{ - length -= availiable; - } + Chunk* c = nullptr; + if (!this->ready_cks.empty()) { + c = this->ready_cks.back(); + uint32_t availiable = c->block_size - c->r_ofs; + if (availiable < length) { + return false; + } else { + length -= availiable; } + } - if(this->ck_free_ck_capacity >=length) - { - return true; - } + if (this->ck_free_ck_capacity >= length) { return true; } - return false; + return false; } -int Chunks::copyDataIntoChunks(const void*data, uint32_t length) +int Chunks::copyDataIntoChunks(const void* data, uint32_t length) { - const char* p_in = (const char*) data; - int ret = 0; - - // fill order - // 1. ready ck - // 2. free ck - // 3. create a new ck - if ((ret = copyDataIntoReadyCK(p_in, length)) == 0) - { - goto DONE; - } + const char* p_in = (const char*) data; + int ret = 0; - p_in += (length - ret); - length = ret; + // fill order + // 1. ready ck + // 2. free ck + // 3. create a new ck + if ((ret = copyDataIntoReadyCK(p_in, length)) == 0) { goto DONE; } - if ((ret = copyDataIntoFreeCK(p_in, length)) == 0) - { - goto DONE; - } + p_in += (length - ret); + length = ret; - p_in += (length - ret); - length = ret; + if ((ret = copyDataIntoFreeCK(p_in, length)) == 0) { goto DONE; } - if ((ret = copyDataIntoNewChunk(p_in, length)) == -1) - { - // exhausting memory - return -1; - } + p_in += (length - ret); + length = ret; + + if ((ret = copyDataIntoNewChunk(p_in, length)) == -1) { + // exhausting memory + return -1; + } DONE: - return 0; + return 0; } int Chunks::drainOutWithPipe(std::function in_pipe_cb) { - if (this->ready_cks.empty()) - { - return 0; - } - this->iter = this->ready_cks.begin(); - - while (this->iter != this->ready_cks.end()) - { - Chunk* cur = *iter; - char* cur_buf = &cur->data[cur->l_ofs]; - uint32_t cur_size = cur->r_ofs - cur->l_ofs; - // call in_pipe_cb flush the data out - int ret = in_pipe_cb(cur_buf, cur_size); - if (ret <= 0) - { - return ret; - } - else if (ret == (int)cur_size) - { // current chunk is done, drop current chunk - // reset read offset - cur->l_ofs = 0; - //reset write offset - cur->r_ofs = 0; - // insert into free cks - this->ck_free_ck_capacity +=cur->block_size; - this->free_cks.push_front(cur); - // remove from read cks - iter++; - this->ready_cks.pop_front(); - } - else if (ret < (int)cur_size) - { // some are failed, resend at next time - cur->l_ofs += (uint32_t)ret; - } - } - this->checkWaterLevel(); - return 0; + if (this->ready_cks.empty()) { return 0; } + this->iter = this->ready_cks.begin(); + + while (this->iter != this->ready_cks.end()) { + Chunk* cur = *iter; + char* cur_buf = &cur->data[cur->l_ofs]; + uint32_t cur_size = cur->r_ofs - cur->l_ofs; + // call in_pipe_cb flush the data out + int ret = in_pipe_cb(cur_buf, cur_size); + if (ret <= 0) { + return ret; + } else if (ret == (int) cur_size) { // current chunk is done, drop current chunk + // reset read offset + cur->l_ofs = 0; + //reset write offset + cur->r_ofs = 0; + // insert into free cks + this->ck_free_ck_capacity += cur->block_size; + this->free_cks.push_front(cur); + // remove from read cks + iter++; + this->ready_cks.pop_front(); + } else if (ret < (int) cur_size) { // some are failed, resend at next time + cur->l_ofs += (uint32_t) ret; + } + } + this->checkWaterLevel(); + return 0; } void Chunks::resetChunks() { - while (!this->ready_cks.empty()) - { - Chunk* c = *this->ready_cks.begin(); - c->l_ofs = 0; - c->r_ofs = 0; - this->ready_cks.pop_front(); - this->ck_free_ck_capacity +=c->block_size; - this->free_cks.push_back(c); - } - this->checkWaterLevel(); + while (!this->ready_cks.empty()) { + Chunk* c = *this->ready_cks.begin(); + c->l_ofs = 0; + c->r_ofs = 0; + this->ready_cks.pop_front(); + this->ck_free_ck_capacity += c->block_size; + this->free_cks.push_back(c); + } + this->checkWaterLevel(); } -} \ No newline at end of file +} // namespace Cache \ No newline at end of file diff --git a/common/src/Cache/NodeTreeWriter.cpp b/common/src/Cache/NodeTreeWriter.cpp index 2402b4b71..edee091bb 100644 --- a/common/src/Cache/NodeTreeWriter.cpp +++ b/common/src/Cache/NodeTreeWriter.cpp @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////////////////////////// // Copyright 2020 NAVER Corp -// +// // Licensed 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 @@ -22,6 +22,6 @@ #include "NodeTreeWriter.h" -namespace Cache { - +namespace Cache +{ } /* namespace Cache */ diff --git a/common/src/Cache/SafeSharedState.cpp b/common/src/Cache/SafeSharedState.cpp index a410e0541..989c710d2 100644 --- a/common/src/Cache/SafeSharedState.cpp +++ b/common/src/Cache/SafeSharedState.cpp @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////////////////////////// // Copyright 2020 NAVER Corp -// +// // Licensed 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 @@ -22,55 +22,48 @@ #include "SafeSharedState.h" #include -namespace Cache { +namespace Cache +{ bool SafeSharedState::checkTraceLimit(int64_t timestamp) { - time_t ts = (timestamp != -1) ?(timestamp) :(std::time(NULL)); - - if(global_agent_info.trace_limit == -1) - { - return false; - } + time_t ts = (timestamp != -1) ? (timestamp) : (std::time(NULL)); + + if (global_agent_info.trace_limit == -1) { return false; } - if(global_agent_info.trace_limit == 0) - { - // block without any checking - goto BLOCK; - } + if (global_agent_info.trace_limit == 0) { + // block without any checking + goto BLOCK; + } - if( this->_global_state->timestamp != ts ) - { - this->_global_state->timestamp = ts; - this->_global_state->tick = 0 ; - __sync_synchronize(); - } - else if(this->_global_state->tick >= global_agent_info.trace_limit) - { - goto BLOCK; + if (this->_global_state->timestamp != ts) { + this->_global_state->timestamp = ts; + this->_global_state->tick = 0; + __sync_synchronize(); + } else if (this->_global_state->tick >= global_agent_info.trace_limit) { + goto BLOCK; // note: if offline, just test it in 5secs // }else if(this->isReady() == false){ // goto BLOCK; - }else - { - __sync_add_and_fetch(&this->_global_state->tick,1); - } - return false; + } else { + __sync_add_and_fetch(&this->_global_state->tick, 1); + } + return false; BLOCK: - pp_trace("This span dropped. max_trace_limit:%ld current_tick:%lld onLine:%d",global_agent_info.trace_limit, - this->_global_state->tick,this->isReady()?(1):(0)); - return true; + pp_trace("This span dropped. max_trace_limit:%ld current_tick:%lld onLine:%d", global_agent_info.trace_limit, this->_global_state->tick, + this->isReady() ? (1) : (0)); + return true; } SafeSharedState::SafeSharedState() { - // this->shmObj = ; - if(attach_shared_memory(&this->shmObj)){ - this->_global_state = (SharedState*)this->shmObj.region; - return ; - } - - throw std::runtime_error("can not attach shm memory"); + // this->shmObj = ; + if (attach_shared_memory(&this->shmObj)) { + this->_global_state = (SharedState*) this->shmObj.region; + return; + } + + throw std::runtime_error("can not attach shm memory"); } } /* namespace Cache */ diff --git a/common/src/ConnectionPool/SpanConnectionPool.cpp b/common/src/ConnectionPool/SpanConnectionPool.cpp index 5898fbaeb..6a91e37bd 100644 --- a/common/src/ConnectionPool/SpanConnectionPool.cpp +++ b/common/src/ConnectionPool/SpanConnectionPool.cpp @@ -26,82 +26,68 @@ namespace ConnectionPool { - using Cache::SafeSharedState; - namespace Json = AliasJson; - SpanConnectionPool::SpanConnectionPool(const char *co_host) : co_host(co_host), - con_counter(0) - { - this->_cPool.push(this->createTrans()); - } +using Cache::SafeSharedState; +namespace Json = AliasJson; +SpanConnectionPool::SpanConnectionPool(const char *co_host) : co_host(co_host), con_counter(0) { this->_cPool.push(this->createTrans()); } - TransConnection SpanConnectionPool::createTrans() - { - TransConnection _connect(new TransLayer(this->co_host)); - using namespace std::placeholders; - // _connect->registerPeerMsgCallback( - // std::bind(&SpanConnectionPool::_handleMsgFromCollector,this,_1,_2,_3), - // std::bind(&SpanConnectionPool::_handleTransLayerState,this,_1)); - - _connect->registerPeerMsgCallback( - std::bind(&SpanConnectionPool::_handleMsgFromCollector, this, _1, _2, _3), - nullptr); - this->con_counter++; +TransConnection SpanConnectionPool::createTrans() +{ + TransConnection _connect(new TransLayer(this->co_host)); + using namespace std::placeholders; + // _connect->registerPeerMsgCallback( + // std::bind(&SpanConnectionPool::_handleMsgFromCollector,this,_1,_2,_3), + // std::bind(&SpanConnectionPool::_handleTransLayerState,this,_1)); - return _connect; - } + _connect->registerPeerMsgCallback(std::bind(&SpanConnectionPool::_handleMsgFromCollector, this, _1, _2, _3), nullptr); + this->con_counter++; - //@obsoleted - // void SpanConnectionPool::_handleTransLayerState(int state) - // { - // if(state == E_OFFLINE) - // { - // if(global_agent_info.inter_flag & E_UTEST){ - // SafeSharedState::instance().markONLine(); - // } - // else{ - // SafeSharedState::instance().markOFFLine(); - // } - // } - // } + return _connect; +} - void SpanConnectionPool::_handleMsgFromCollector(int type, const char *buf, size_t len) - { - switch (type) - { +//@obsoleted +// void SpanConnectionPool::_handleTransLayerState(int state) +// { +// if(state == E_OFFLINE) +// { +// if(global_agent_info.inter_flag & E_UTEST){ +// SafeSharedState::instance().markONLine(); +// } +// else{ +// SafeSharedState::instance().markOFFLine(); +// } +// } +// } - case RESPONSE_AGENT_INFO: - this->_handle_agent_info(type, buf, len); - break; +void SpanConnectionPool::_handleMsgFromCollector(int type, const char *buf, size_t len) +{ + switch (type) { + case RESPONSE_AGENT_INFO: + this->_handle_agent_info(type, buf, len); + break; - default: - break; - } - } + default: + break; + } +} - void SpanConnectionPool::_handle_agent_info(int type, const char *buf, size_t len) - { - Json::Value root; - (void)type; - Json::CharReaderBuilder builder; - builder["collectComments"] = false; +void SpanConnectionPool::_handle_agent_info(int type, const char *buf, size_t len) +{ + Json::Value root; + (void) type; + Json::CharReaderBuilder builder; + builder["collectComments"] = false; - std::istringstream inss(std::string(buf, len)); - JSONCPP_STRING errs; - bool ok = parseFromStream(builder, inss, &root, &errs); + std::istringstream inss(std::string(buf, len)); + JSONCPP_STRING errs; + bool ok = parseFromStream(builder, inss, &root, &errs); - if (ok) - { - // pp_trace("collector-agent say:%s",root.toStyledString().c_str()); + if (ok) { + // pp_trace("collector-agent say:%s",root.toStyledString().c_str()); - if (root.isMember("time")) - { - SafeSharedState::instance().updateStartTime(atoll(root["time"].asCString())); - } - } - else - { - pp_trace("Recieve invalid msg: %.*s from Collector-agent, reason: %s", (int)len, buf, errs.c_str()); - } - } + if (root.isMember("time")) { SafeSharedState::instance().updateStartTime(atoll(root["time"].asCString())); } + } else { + pp_trace("Recieve invalid msg: %.*s from Collector-agent, reason: %s", (int) len, buf, errs.c_str()); + } +} } /* namespace ConnectionPool */ diff --git a/common/src/ConnectionPool/TransLayer.cpp b/common/src/ConnectionPool/TransLayer.cpp index 5a1b34d99..35c6bee5b 100644 --- a/common/src/ConnectionPool/TransLayer.cpp +++ b/common/src/ConnectionPool/TransLayer.cpp @@ -17,225 +17,181 @@ #include namespace ConnectionPool { - /** +/** * remote: localhost:port */ - int TransLayer::connect_stream_remote(const char *remote) - { - - int offset = strlen(remote) - 1; - - while (remote[offset] != ':') - { - offset--; - if (offset <= 0) - { - pp_trace("get an invalid remote %s", remote); - return -1; - } - } - - std::string hostname(remote, offset); - const char *port_str = remote + offset + 1; - // int port = atoi(remote+offset+1); - - struct addrinfo hints; - struct addrinfo *result, *rp; - memset(&hints, 0, sizeof(hints)); - hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ - hints.ai_socktype = SOCK_STREAM; /* Datagram socket */ - hints.ai_flags = 0; - hints.ai_protocol = 0; /* Any protocol */ - - int s = 0; - s = getaddrinfo(hostname.c_str(), port_str, &hints, &result); - if (s != 0) - { - pp_trace("getaddrinfo failed: hostname:%s msg:%s ", hostname.c_str(), gai_strerror(s)); - return -1; - } - int sfd = -1; - for (rp = result; rp != NULL; rp = rp->ai_next) - { - sfd = socket(rp->ai_family, rp->ai_socktype, - rp->ai_protocol); - - struct linger fd_linger = {1, 1}; // open and 1 second - // mark it as nonblock - fcntl(sfd, F_SETFL, fcntl(sfd, F_GETFL, 0) | O_NONBLOCK); - setsockopt(sfd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); - - if (sfd == -1) - continue; - int ret = connect(sfd, rp->ai_addr, rp->ai_addrlen); - if (ret == 0) - { - break; - } - else if (ret == -1) - { - if (errno == EALREADY || errno == EINPROGRESS) - break; - } - - close(sfd); - sfd = -1; - } - freeaddrinfo(result); - - return sfd; +int TransLayer::connect_stream_remote(const char *remote) +{ + int offset = strlen(remote) - 1; + + while (remote[offset] != ':') { + offset--; + if (offset <= 0) { + pp_trace("get an invalid remote %s", remote); + return -1; } + } + + std::string hostname(remote, offset); + const char *port_str = remote + offset + 1; + // int port = atoi(remote+offset+1); + + struct addrinfo hints; + struct addrinfo *result, *rp; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ + hints.ai_socktype = SOCK_STREAM; /* Datagram socket */ + hints.ai_flags = 0; + hints.ai_protocol = 0; /* Any protocol */ + + int s = 0; + s = getaddrinfo(hostname.c_str(), port_str, &hints, &result); + if (s != 0) { + pp_trace("getaddrinfo failed: hostname:%s msg:%s ", hostname.c_str(), gai_strerror(s)); + return -1; + } + int sfd = -1; + for (rp = result; rp != NULL; rp = rp->ai_next) { + sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + + struct linger fd_linger = {1, 1}; // open and 1 second + // mark it as nonblock + fcntl(sfd, F_SETFL, fcntl(sfd, F_GETFL, 0) | O_NONBLOCK); + setsockopt(sfd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); + + if (sfd == -1) continue; + int ret = connect(sfd, rp->ai_addr, rp->ai_addrlen); + if (ret == 0) { + break; + } else if (ret == -1) { + if (errno == EALREADY || errno == EINPROGRESS) break; + } + + close(sfd); + sfd = -1; + } + freeaddrinfo(result); - int TransLayer::connect_unix_remote(const char *remote) - { - int fd = -1; + return sfd; +} + +int TransLayer::connect_unix_remote(const char *remote) +{ + int fd = -1; #if defined(__APPLE__) - struct sockaddr_un u_sock = {0, 0, {0}}; + struct sockaddr_un u_sock = {0, 0, {0}}; #else - struct sockaddr_un u_sock = {0, {0}}; + struct sockaddr_un u_sock = {0, {0}}; #endif - struct linger fd_linger = {1, 1}; // open and 1 second - if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) - { - pp_trace(" get socket error,(%s)", strerror(errno)); - goto ERROR; - } - - u_sock.sun_family = AF_UNIX; - strncpy(u_sock.sun_path, remote, sizeof(u_sock.sun_path) - 1); - - // mark fd as non blocking - fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK); - - setsockopt(fd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); - - if (connect(fd, (struct sockaddr *)&u_sock, sizeof(u_sock)) != 0) - { - if (errno != EALREADY || errno != EINPROGRESS) - { - pp_trace("connect:(%s) failed as (%s)", remote, strerror(errno)); - goto ERROR; - } - } - pp_trace("connected to %s", remote); - - return fd; - - ERROR: - if (fd > 0) - { - close(fd); - } - - return -1; + struct linger fd_linger = {1, 1}; // open and 1 second + if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + pp_trace(" get socket error,(%s)", strerror(errno)); + goto ERROR; + } + + u_sock.sun_family = AF_UNIX; + strncpy(u_sock.sun_path, remote, sizeof(u_sock.sun_path) - 1); + + // mark fd as non blocking + fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK); + + setsockopt(fd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); + + if (connect(fd, (struct sockaddr *) &u_sock, sizeof(u_sock)) != 0) { + if (errno != EALREADY || errno != EINPROGRESS) { + pp_trace("connect:(%s) failed as (%s)", remote, strerror(errno)); + goto ERROR; } + } + pp_trace("connected to %s", remote); + + return fd; + +ERROR: + if (fd > 0) { close(fd); } + + return -1; +} + +size_t TransLayer::trans_layer_pool(uint32_t timeout) +{ + if (c_fd == -1) { + pp_trace("agent try to connect:(%s)", this->co_host.c_str()); + connect_remote(this->co_host.c_str()); - size_t TransLayer::trans_layer_pool(uint32_t timeout) - { - if (c_fd == -1) - { - pp_trace("agent try to connect:(%s)", this->co_host.c_str()); - connect_remote(this->co_host.c_str()); - - if (c_fd == -1) - { - return -1; - } - } - - int fd = c_fd; - fd_set wfds, efds, rfds; - FD_ZERO(&efds); - - FD_ZERO(&wfds); - FD_ZERO(&rfds); - - if (this->_state & S_ERROR) - { - FD_SET(fd, &efds); - } - - if (this->_state & S_WRITING) - { - FD_SET(fd, &wfds); - } - - if (this->_state & S_READING) - { - FD_SET(fd, &rfds); - } - - struct timeval tv = {0, (int)timeout * 1000}; - - int retval = select(fd + 1, &rfds, &wfds, &efds, &tv); - if (retval == -1) - { - // it helped address the macosx issue - pp_trace("select return error:(%s)", strerror(errno)); - return -1; - } - else if (retval > 0) - { - - if ((this->_state & S_ERROR) && FD_ISSET(fd, &efds)) - { - pp_trace("select fd:(%s) ", strerror(errno)); - goto ERROR; - } - - if ((this->_state & S_WRITING) && FD_ISSET(fd, &wfds)) - { - if (_send_msg_to_collector() == -1) - { - goto ERROR; - } - } - - if ((this->_state & S_READING) && FD_ISSET(fd, &rfds)) - { - if (_recv_msg_from_collector() == -1) - { - pp_trace("recv_msg_from_collector error"); - goto ERROR; - } - } - } - else - { - // timeout do nothing - // total =0 ,timeout - } - - return 0; - - ERROR: - - _reset_remote(); - - connect_remote(this->co_host.c_str()); - return -1; + if (c_fd == -1) { return -1; } + } + + int fd = c_fd; + fd_set wfds, efds, rfds; + FD_ZERO(&efds); + + FD_ZERO(&wfds); + FD_ZERO(&rfds); + + if (this->_state & S_ERROR) { FD_SET(fd, &efds); } + + if (this->_state & S_WRITING) { FD_SET(fd, &wfds); } + + if (this->_state & S_READING) { FD_SET(fd, &rfds); } + + struct timeval tv = {0, (int) timeout * 1000}; + + int retval = select(fd + 1, &rfds, &wfds, &efds, &tv); + if (retval == -1) { + // it helped address the macosx issue + pp_trace("select return error:(%s)", strerror(errno)); + return -1; + } else if (retval > 0) { + if ((this->_state & S_ERROR) && FD_ISSET(fd, &efds)) { + pp_trace("select fd:(%s) ", strerror(errno)); + goto ERROR; } - bool TransLayer::copy_into_send_buffer(const std::string &data) - { - Header header; - header.length = htonl(data.size()); - header.type = htonl(REQ_UPDATE_SPAN); - - if (this->chunks.checkCapacity(sizeof(header) + data.size()) == false) - { - pp_trace("Send buffer is full. size:[%ld]", data.size() + sizeof(header)); - return false; - } - // copy header - this->chunks.copyDataIntoChunks((const char *)&header, sizeof(header)); - // copy body - this->chunks.copyDataIntoChunks(data.data(), data.size()); - // enable write event - this->_state |= S_WRITING; - return true; + if ((this->_state & S_WRITING) && FD_ISSET(fd, &wfds)) { + if (_send_msg_to_collector() == -1) { goto ERROR; } } - const char *TransLayer::UNIX_SOCKET = "unix:"; - const char *TransLayer::TCP_SOCKET = "tcp:"; -} \ No newline at end of file + if ((this->_state & S_READING) && FD_ISSET(fd, &rfds)) { + if (_recv_msg_from_collector() == -1) { + pp_trace("recv_msg_from_collector error"); + goto ERROR; + } + } + } else { + // timeout do nothing + // total =0 ,timeout + } + + return 0; + +ERROR: + + _reset_remote(); + + connect_remote(this->co_host.c_str()); + return -1; +} + +bool TransLayer::copy_into_send_buffer(const std::string &data) +{ + Header header; + header.length = htonl(data.size()); + header.type = htonl(REQ_UPDATE_SPAN); + + if (this->chunks.checkCapacity(sizeof(header) + data.size()) == false) { + pp_trace("Send buffer is full. size:[%ld]", data.size() + sizeof(header)); + return false; + } + // copy header + this->chunks.copyDataIntoChunks((const char *) &header, sizeof(header)); + // copy body + this->chunks.copyDataIntoChunks(data.data(), data.size()); + // enable write event + this->_state |= S_WRITING; + return true; +} + +const char *TransLayer::UNIX_SOCKET = "unix:"; +const char *TransLayer::TCP_SOCKET = "tcp:"; +} // namespace ConnectionPool \ No newline at end of file diff --git a/common/src/Context/ContextType.cpp b/common/src/Context/ContextType.cpp index 5518ba107..3d2a27595 100644 --- a/common/src/Context/ContextType.cpp +++ b/common/src/Context/ContextType.cpp @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////////////////////////// // Copyright 2020 NAVER Corp -// +// // Licensed 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 @@ -22,6 +22,6 @@ #include "ContextType.h" -namespace Context { - +namespace Context +{ } /* namespace Context */ diff --git a/common/src/NodePool/PoolManager.cpp b/common/src/NodePool/PoolManager.cpp index 7c251bfee..b7b06bc45 100644 --- a/common/src/NodePool/PoolManager.cpp +++ b/common/src/NodePool/PoolManager.cpp @@ -32,146 +32,114 @@ namespace NodePool { +void freeNodeTree(NodeID nodeId) +{ + if (nodeId == E_INVALID_NODE || nodeId == E_ROOT_NODE) { return; } + + NodeID child_id, next_id; + + if (PoolManager::getInstance().Restore(nodeId, child_id, next_id)) { + if (next_id != E_INVALID_NODE) { freeNodeTree(next_id); } + + if (child_id != E_INVALID_NODE) { freeNodeTree(child_id); } + } + + // while (child_id != E_INVALID_NODE) + // { + // WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(child_id); + // next_id = r_node->mNextId; + // freeNodeTree(child_id); + // child_id = next_id; + // } + + // PoolManager::getInstance().Restore(rootId); +} +bool PoolManager::Restore(NodeID id, NodeID &child_id, NodeID &next_id) +{ + for (int i = 0; i < 1000; i++) { + if (this->_restore(id, child_id, next_id, false)) { return true; } + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + pp_trace("[🐛]Restore node failed: #%d; node restore forcefully", id); + return this->_restore(id, child_id, next_id, true); +} + +// avoiding `locking and waitting` +bool PoolManager::_restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force) +{ + std::lock_guard _safe(this->_lock); + + int32_t index = (int32_t) id - 1; + + if (this->indexInAliveVec(index) == false) { + pp_trace("%d not alive !!!", id); + child_id = E_INVALID_NODE; + next_id = E_INVALID_NODE; + return true; + } + + // check refcount + TraceNode &node = this->_fetchNodeBy(id); + + if (node.checkZoreRef() == false && force == false) { + // DO NOT TOUCH out id + return false; + } else { + this->_aliveNodeSet[index] = false; + child_id = node.mChildHeadId; + next_id = node.mNextId; + this->_freeNodeList.push(index); + return true; + } +} - void freeNodeTree(NodeID nodeId) - { - if (nodeId == E_INVALID_NODE || nodeId == E_ROOT_NODE) - { - return; - } - - NodeID child_id, next_id; - - if (PoolManager::getInstance().Restore(nodeId, child_id, next_id)) - { - if (next_id != E_INVALID_NODE) - { - freeNodeTree(next_id); - } - - if (child_id != E_INVALID_NODE) - { - freeNodeTree(child_id); - } - } - - // while (child_id != E_INVALID_NODE) - // { - // WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(child_id); - // next_id = r_node->mNextId; - // freeNodeTree(child_id); - // child_id = next_id; - // } - - // PoolManager::getInstance().Restore(rootId); - } - bool PoolManager::Restore(NodeID id, NodeID &child_id, NodeID &next_id) - { - for (int i = 0; i < 1000; i++) - { - if (this->_restore(id, child_id, next_id, false)) - { - return true; - } - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - pp_trace("[🐛]Restore node failed: #%d; node restore forcefully", id); - return this->_restore(id, child_id, next_id, true); - } - - // avoiding `locking and waitting` - bool PoolManager::_restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force) - { - std::lock_guard _safe(this->_lock); - - int32_t index = (int32_t)id - 1; - - if (this->indexInAliveVec(index) == false) - { - pp_trace("%d not alive !!!", id); - child_id = E_INVALID_NODE; - next_id = E_INVALID_NODE; - return true; - } - - // check refcount - TraceNode &node = this->_fetchNodeBy(id); - - if (node.checkZoreRef() == false && force == false) - { - // DO NOT TOUCH out id - return false; - } - else - { - this->_aliveNodeSet[index] = false; - child_id = node.mChildHeadId; - next_id = node.mNextId; - this->_freeNodeList.push(index); - return true; - } - } - - TraceNode &PoolManager::_fetchNodeBy(NodeID id) - { - // assert(id != E_INVALID_NODE); - if (id == E_ROOT_NODE) - { - throw std::out_of_range("id should not be 0"); - } - - int32_t index = int32_t(id) - 1; - - if (this->indexInAliveVec(index) == false) - { - std::string msg = "#"; - msg += std::to_string(id) + " is not alive"; - throw std::out_of_range(msg); - } - - return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE]; - } - - TraceNode &PoolManager::_getInitNode() noexcept - { // create a new node - if (this->_freeNodeList.empty()) - { - this->expandOnce(); - } - // as it holds a _lock, so no more _freeNodeList is empty - int32_t index = this->_freeNodeList.top(); - this->_freeNodeList.pop(); - this->_aliveNodeSet[index] = true; - return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE].reset(NodeID(index + 1)); - } - - TraceNode &PoolManager::_take(NodeID id) - { - if (id != E_ROOT_NODE) - { - return this->_fetchNodeBy(id); - } - else - { - return this->_getInitNode(); - } - } - - void PoolManager::expandOnce() - { - ADDTRACE(); - // pp_trace("Node pool expanding self! Old size:%ld", this->nodeIndexVec.size() * CELL_SIZE); - // append new nodes into nodeIndexVec - this->nodeIndexVec.push_back(std::unique_ptr(new TraceNode[CELL_SIZE])); - // this->nodeIndexVec.push_back(std::make_unique(CELL_SIZE)); - // append new bitflag into aliveNodeSet - this->_aliveNodeSet.insert(this->_aliveNodeSet.end(), this->_emptyAliveSet.begin(), this->_emptyAliveSet.end()); - for (int32_t id = this->maxId; id < (this->maxId + CELL_SIZE); id++) - { - this->_freeNodeList.push(id); - } - this->maxId += CELL_SIZE; - // pp_trace("Node pool expanding is done! news size:%ld", this->nodeIndexVec.size() * CELL_SIZE); - assert(this->nodeIndexVec.size() * CELL_SIZE == this->_aliveNodeSet.size()); - } +TraceNode &PoolManager::_fetchNodeBy(NodeID id) +{ + // assert(id != E_INVALID_NODE); + if (id == E_ROOT_NODE) { throw std::out_of_range("id should not be 0"); } + + int32_t index = int32_t(id) - 1; + + if (this->indexInAliveVec(index) == false) { + std::string msg = "#"; + msg += std::to_string(id) + " is not alive"; + throw std::out_of_range(msg); + } + + return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE]; +} + +TraceNode &PoolManager::_getInitNode() noexcept +{ // create a new node + if (this->_freeNodeList.empty()) { this->expandOnce(); } + // as it holds a _lock, so no more _freeNodeList is empty + int32_t index = this->_freeNodeList.top(); + this->_freeNodeList.pop(); + this->_aliveNodeSet[index] = true; + return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE].reset(NodeID(index + 1)); +} + +TraceNode &PoolManager::_take(NodeID id) +{ + if (id != E_ROOT_NODE) { + return this->_fetchNodeBy(id); + } else { + return this->_getInitNode(); + } +} + +void PoolManager::expandOnce() +{ + ADDTRACE(); + // pp_trace("Node pool expanding self! Old size:%ld", this->nodeIndexVec.size() * CELL_SIZE); + // append new nodes into nodeIndexVec + this->nodeIndexVec.push_back(std::unique_ptr(new TraceNode[CELL_SIZE])); + // this->nodeIndexVec.push_back(std::make_unique(CELL_SIZE)); + // append new bitflag into aliveNodeSet + this->_aliveNodeSet.insert(this->_aliveNodeSet.end(), this->_emptyAliveSet.begin(), this->_emptyAliveSet.end()); + for (int32_t id = this->maxId; id < (this->maxId + CELL_SIZE); id++) { this->_freeNodeList.push(id); } + this->maxId += CELL_SIZE; + // pp_trace("Node pool expanding is done! news size:%ld", this->nodeIndexVec.size() * CELL_SIZE); + assert(this->nodeIndexVec.size() * CELL_SIZE == this->_aliveNodeSet.size()); } +} // namespace NodePool diff --git a/common/src/NodePool/PoolManager.h b/common/src/NodePool/PoolManager.h index cac2f8d0f..57c4efe48 100644 --- a/common/src/NodePool/PoolManager.h +++ b/common/src/NodePool/PoolManager.h @@ -31,38 +31,37 @@ namespace NodePool { +class PoolManager +{ + private: + TraceNode &_fetchNodeBy(NodeID id); - class PoolManager - { - private: - TraceNode &_fetchNodeBy(NodeID id); - - TraceNode &_getInitNode(void) noexcept; + TraceNode &_getInitNode(void) noexcept; - TraceNode &_take(NodeID id); + TraceNode &_take(NodeID id); - bool _restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force); + bool _restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force); - public: - /** + public: + /** * @brief take is not safe, you should avoid use under MT * note: try PoolManager::getInstance().GetWrapperNode * @param id * @return TraceNode& */ - inline TraceNode &Take(NodeID id = E_ROOT_NODE) - { - std::lock_guard _safe(this->_lock); - return this->_take(id); - } - - inline WrapperTraceNode GetWrapperNode(NodeID id = E_ROOT_NODE) - { - std::lock_guard _safe(this->_lock); - TraceNode &e = this->_take(id); - return WrapperTraceNode(&e); - } - /** + inline TraceNode &Take(NodeID id = E_ROOT_NODE) + { + std::lock_guard _safe(this->_lock); + return this->_take(id); + } + + inline WrapperTraceNode GetWrapperNode(NodeID id = E_ROOT_NODE) + { + std::lock_guard _safe(this->_lock); + TraceNode &e = this->_take(id); + return WrapperTraceNode(&e); + } + /** * @brief restore id->traceNode to pool * * @param id @@ -71,91 +70,79 @@ namespace NodePool * @return true * @return false */ - bool Restore(NodeID id, NodeID &child_id, NodeID &next_id); - - inline bool Restore(TraceNode &node) - { - NodeID node1, node2; - return this->Restore(node.getId(), node1, node2); - } - - uint32_t totoalNodesCount() - { - std::lock_guard _safe(this->_lock); - return nodeIndexVec.size() * CELL_SIZE; - } - - uint32_t freeNodesCount() - { - std::lock_guard _safe(this->_lock); - return this->_freeNodeList.size(); - } - - void foreachAliveNode(std::function func) - { - std::lock_guard _safe(this->_lock); - for (int32_t index = 0; index < this->maxId; index++) - { - if (this->indexInAliveVec(index)) - { - func(this->_fetchNodeBy((NodeID)(index + 1))); - } - } - } + bool Restore(NodeID id, NodeID &child_id, NodeID &next_id); + + inline bool Restore(TraceNode &node) + { + NodeID node1, node2; + return this->Restore(node.getId(), node1, node2); + } + + uint32_t totoalNodesCount() + { + std::lock_guard _safe(this->_lock); + return nodeIndexVec.size() * CELL_SIZE; + } + + uint32_t freeNodesCount() + { + std::lock_guard _safe(this->_lock); + return this->_freeNodeList.size(); + } + + void foreachAliveNode(std::function func) + { + std::lock_guard _safe(this->_lock); + for (int32_t index = 0; index < this->maxId; index++) { + if (this->indexInAliveVec(index)) { func(this->_fetchNodeBy((NodeID)(index + 1))); } + } + } #ifdef COMMON_DEBUG - inline bool NoNodeLeak() - { - std::lock_guard _safe(this->_lock); - return this->_freeNodeList.size() == nodeIndexVec.size() * CELL_SIZE; - } + inline bool NoNodeLeak() + { + std::lock_guard _safe(this->_lock); + return this->_freeNodeList.size() == nodeIndexVec.size() * CELL_SIZE; + } #endif - virtual ~PoolManager() - { - } - - public: - static PoolManager &getInstance() - { - static PoolManager _instance; - return _instance; - } + virtual ~PoolManager() {} + + public: + static PoolManager &getInstance() + { + static PoolManager _instance; + return _instance; + } #ifndef COMMON_DEBUG - private: + private: #endif - PoolManager() : maxId(E_ROOT_NODE) - { - this->_emptyAliveSet.reserve(CELL_SIZE); - for (int i = 0; i < CELL_SIZE; i++) - { - this->_emptyAliveSet.push_back(false); - } - this->expandOnce(); - } - - private: - inline bool indexInAliveVec(int32_t index) - { - if (index >= 0 && index < this->maxId) - { - return this->_aliveNodeSet.at(index); - } - return false; - } - - void expandOnce(); - - private: - std::mutex _lock; - // std::set _aliveNodeSet; - std::vector _aliveNodeSet; - std::vector _emptyAliveSet; - int32_t maxId; - std::stack _freeNodeList; - static const int CELL_SIZE = 128; - std::vector> nodeIndexVec; - }; - void freeNodeTree(NodeID root); -} + PoolManager() : maxId(E_ROOT_NODE) + { + this->_emptyAliveSet.reserve(CELL_SIZE); + for (int i = 0; i < CELL_SIZE; i++) { this->_emptyAliveSet.push_back(false); } + this->expandOnce(); + } + + private: + inline bool indexInAliveVec(int32_t index) + { + if (index >= 0 && index < this->maxId) { return this->_aliveNodeSet.at(index); } + return false; + } + + void expandOnce(); + + private: + std::mutex _lock; + // std::set _aliveNodeSet; + std::vector _aliveNodeSet; + std::vector _emptyAliveSet; + int32_t maxId; + std::stack _freeNodeList; + static const int CELL_SIZE = 128; + std::vector> nodeIndexVec; +}; +void freeNodeTree(NodeID root); +} // namespace NodePool #endif /* COMMON_SRC_NODEPOOL_POOLMANAGER_H_ */ diff --git a/common/src/NodePool/TraceNode.cpp b/common/src/NodePool/TraceNode.cpp index 43e362b62..da557627e 100644 --- a/common/src/NodePool/TraceNode.cpp +++ b/common/src/NodePool/TraceNode.cpp @@ -27,154 +27,123 @@ namespace NodePool { - // static std::atomic _uid_; - WrapperTraceNode::WrapperTraceNode(TraceNode *node) : _traceNode(node) - { - assert(_traceNode != nullptr); - _traceNode->addRef(); - } +// static std::atomic _uid_; +WrapperTraceNode::WrapperTraceNode(TraceNode *node) : _traceNode(node) +{ + assert(_traceNode != nullptr); + _traceNode->addRef(); +} - WrapperTraceNode::~WrapperTraceNode() - { - if (_traceNode != nullptr) - { - _traceNode->rmRef(); - } - } - TraceNode::~TraceNode() - { - } +WrapperTraceNode::~WrapperTraceNode() +{ + if (_traceNode != nullptr) { _traceNode->rmRef(); } +} +TraceNode::~TraceNode() {} - void TraceNode::clearAttach() - { - // empty the json value - if (!this->_value.empty()) - this->_value.clear(); // Json::Value(); +void TraceNode::clearAttach() +{ + // empty the json value + if (!this->_value.empty()) this->_value.clear(); // Json::Value(); - if (!this->_context.empty()) - this->_context.clear(); + if (!this->_context.empty()) this->_context.clear(); - if (!this->_endTraceCallback.empty()) - this->_endTraceCallback.clear(); - } + if (!this->_endTraceCallback.empty()) this->_endTraceCallback.clear(); +} - void TraceNode::initId(NodeID &id) - { - this->mPoolIndex = id; - } +void TraceNode::initId(NodeID &id) { this->mPoolIndex = id; } - void TraceNode::addChild(WrapperTraceNode &child) - { - std::lock_guard _safe(this->mlock); +void TraceNode::addChild(WrapperTraceNode &child) +{ + std::lock_guard _safe(this->mlock); - if (this->mChildHeadId != E_INVALID_NODE) - child->mNextId = this->mChildHeadId; + if (this->mChildHeadId != E_INVALID_NODE) child->mNextId = this->mChildHeadId; - this->mChildHeadId = child->mPoolIndex; + this->mChildHeadId = child->mPoolIndex; - child->mParentId = this->mPoolIndex; - child->mRootIndex = this->mRootIndex; - child->root_start_time = this->root_start_time; - } + child->mParentId = this->mPoolIndex; + child->mRootIndex = this->mRootIndex; + child->root_start_time = this->root_start_time; +} - void TraceNode::endTimer() - { +void TraceNode::endTimer() +{ + uint64_t end_time = Helper::get_current_msec_stamp(); - uint64_t end_time = Helper::get_current_msec_stamp(); + this->cumulative_time += (end_time - this->start_time); +} - this->cumulative_time += (end_time - this->start_time); - } +void TraceNode::wakeUp() { this->start_time = Helper::get_current_msec_stamp(); } - void TraceNode::wakeUp() - { - this->start_time = Helper::get_current_msec_stamp(); - } +void TraceNode::convertToSpan() +{ + this->AddTraceDetail("E", this->cumulative_time); + this->AddTraceDetail("S", this->start_time); - void TraceNode::convertToSpan() - { - this->AddTraceDetail("E", this->cumulative_time); - this->AddTraceDetail("S", this->start_time); + this->AddTraceDetail("FT", global_agent_info.agent_type); +} - this->AddTraceDetail("FT", global_agent_info.agent_type); - } +void TraceNode::convertToSpanEvent() +{ + this->AddTraceDetail("E", this->cumulative_time); + this->AddTraceDetail("S", this->start_time - this->root_start_time); +} - void TraceNode::convertToSpanEvent() - { - this->AddTraceDetail("E", this->cumulative_time); - this->AddTraceDetail("S", this->start_time - this->root_start_time); - } +// void TraceNode::setTraceParent(WrapperTraceNode &parent, WrapperTraceNode &root) +// { +// std::lock_guard _safe(this->mlock); +// this->mRootIndex = root->mPoolIndex; +// this->mParentId = parent->mPoolIndex; +// this->root_start_time = root->root_start_time; +// } - // void TraceNode::setTraceParent(WrapperTraceNode &parent, WrapperTraceNode &root) - // { - // std::lock_guard _safe(this->mlock); - // this->mRootIndex = root->mPoolIndex; - // this->mParentId = parent->mPoolIndex; - // this->root_start_time = root->root_start_time; - // } - - void TraceNode::startTimer() - { - uint64_t time_in_ms = Helper::get_current_msec_stamp(); - this->start_time = time_in_ms; - this->root_start_time = time_in_ms; - } +void TraceNode::startTimer() +{ + uint64_t time_in_ms = Helper::get_current_msec_stamp(); + this->start_time = time_in_ms; + this->root_start_time = time_in_ms; +} - void TraceNode::parseOpt(std::string key, std::string value) - { - pp_trace("#%d add opt: key:%s value:%s", mPoolIndex, key.c_str(), value.c_str()); - if (key == "TraceMinTimeMs") - { - int64_t min = std::stoll(value); - auto cb = [=]() -> bool - { - pp_trace("checkOpt: #%d TraceMinTimeMs:%ld cumulative_time:%lu", this->mPoolIndex, min, this->cumulative_time); - if ((int64_t)this->cumulative_time >= min) - return true; - return false; - }; - this->_endTraceCallback.push_back(cb); - } - else if (key == "TraceOnlyException") - { - auto cb = [=]() -> bool - { - return this->mHasExp; - }; - - this->_endTraceCallback.push_back(cb); - } - } +void TraceNode::parseOpt(std::string key, std::string value) +{ + pp_trace("#%d add opt: key:%s value:%s", mPoolIndex, key.c_str(), value.c_str()); + if (key == "TraceMinTimeMs") { + int64_t min = std::stoll(value); + auto cb = [=]() -> bool { + pp_trace("checkOpt: #%d TraceMinTimeMs:%ld cumulative_time:%lu", this->mPoolIndex, min, this->cumulative_time); + if ((int64_t) this->cumulative_time >= min) return true; + return false; + }; + this->_endTraceCallback.push_back(cb); + } else if (key == "TraceOnlyException") { + auto cb = [=]() -> bool { return this->mHasExp; }; + + this->_endTraceCallback.push_back(cb); + } +} - bool TraceNode::checkOpt() - { - bool ret = true; - for (auto &cb : this->_endTraceCallback) - { - if ((ret = cb()) == true) - return ret; - } - return ret; - } +bool TraceNode::checkOpt() +{ + bool ret = true; + for (auto &cb : this->_endTraceCallback) { + if ((ret = cb()) == true) return ret; + } + return ret; +} - void TraceNode::setOpt(const char *opt, va_list *args) - { - const char *var = opt; - - while (var != nullptr) - { - - const char *delimit = strchr(var, ':'); - if (delimit == nullptr) - { - this->parseOpt(std::string(var), ""); - } - else - { - std::string key(var, delimit - var); - std::string value(delimit + 1); - this->parseOpt(key, value); - } - var = va_arg(*args, const char *); - } +void TraceNode::setOpt(const char *opt, va_list *args) +{ + const char *var = opt; + + while (var != nullptr) { + const char *delimit = strchr(var, ':'); + if (delimit == nullptr) { + this->parseOpt(std::string(var), ""); + } else { + std::string key(var, delimit - var); + std::string value(delimit + 1); + this->parseOpt(key, value); } + var = va_arg(*args, const char *); + } } +} // namespace NodePool diff --git a/common/src/NodePool/TraceNode.h b/common/src/NodePool/TraceNode.h index f504757eb..fac8c636d 100644 --- a/common/src/NodePool/TraceNode.h +++ b/common/src/NodePool/TraceNode.h @@ -34,278 +34,249 @@ namespace NodePool { +namespace Json = AliasJson; +using Context::ContextType; +using Context::LongContextType; +using Context::StringContextType; +class TraceNode; +const static int MAX_SUB_TRACE_NODES_LIMIT = 2048; +class WrapperTraceNode +{ + public: + WrapperTraceNode() = delete; + WrapperTraceNode(const WrapperTraceNode &other) = delete; + WrapperTraceNode(WrapperTraceNode &&other) : _traceNode(std::move(other._traceNode)) { other._traceNode = nullptr; } + + WrapperTraceNode &operator=(const WrapperTraceNode &other) = delete; + + WrapperTraceNode(TraceNode *node); + TraceNode *operator->() { return _traceNode; } + ~WrapperTraceNode(); - namespace Json = AliasJson; - using Context::ContextType; - using Context::LongContextType; - using Context::StringContextType; - class TraceNode; - const static int MAX_SUB_TRACE_NODES_LIMIT = 2048; - class WrapperTraceNode - { - public: - WrapperTraceNode() = delete; - WrapperTraceNode(const WrapperTraceNode &other) = delete; - WrapperTraceNode(WrapperTraceNode &&other) : _traceNode(std::move(other._traceNode)) - { - other._traceNode = nullptr; - } - - WrapperTraceNode &operator=(const WrapperTraceNode &other) = delete; - - WrapperTraceNode(TraceNode *node); - TraceNode *operator->() - { - return _traceNode; - } - ~WrapperTraceNode(); - - private: - TraceNode *_traceNode; - }; - - typedef std::shared_ptr _ContextType_; - class TraceNode - { - public: - NodeID mNextId; // equal brother node - NodeID mChildHeadId; // subtree/child tree - - NodeID mParentId; // parent Id [end_trace] avoiding re-add - NodeID mRootIndex; // highway to root node - NodeID mPoolIndex; - // int64_t mUID; - // int64_t mParentUID; - // int64_t mRootUID; - - uint64_t start_time; - uint64_t fetal_error_time; - uint64_t limit; - uint64_t cumulative_time; - uint64_t root_start_time; - bool mHasExp; - - public: - void startTimer(); - void endTimer(); - void wakeUp(); - - void convertToSpanEvent(); - void convertToSpan(); - - public: - void addChild(WrapperTraceNode &child); - void remove(); - - inline bool isRoot() const - { - return this->mRootIndex == mPoolIndex; - } - - inline bool isLeaf() const - { - return this->mChildHeadId == E_INVALID_NODE; - } - - public: - TraceNode() - { - this->mPoolIndex = E_INVALID_NODE; - this->mRootIndex = E_INVALID_NODE; - this->resetRelative(); - this->resetStatus(); - this->_mRef = 0; - } - - virtual ~TraceNode(); - - TraceNode &reset(NodeID id) - { - std::lock_guard _safe(this->mlock); - this->clearAttach(); - this->initId(id); - this->resetStatus(); - this->resetRelative(); - this->_mRef = 0; - return *this; - } - - NodeID getId() const - { - return this->mPoolIndex; - } - - Json::Value getJsValue() - { - std::lock_guard _safe(this->mlock); - return this->_value; - } - - void getContext(const char *key, std::string &value) - { - std::lock_guard _safe(this->mlock); - _ContextType_ &ctx = this->_context.at(key); - value = ctx->asStringValue(); - } - - void getContext(const char *key, long &value) - { - std::lock_guard _safe(this->mlock); - _ContextType_ &ctx = this->_context.at(key); - value = ctx->asLongValue(); - } - - void setContext(const char *key, const char *buf) - { - std::lock_guard _safe(this->mlock); - _ContextType_ context(std::make_shared(buf)); - this->_context[key] = context; - } - - void setContext(const char *key, long l) - { - std::lock_guard _safe(this->mlock); - _ContextType_ context(std::make_shared(l)); - this->_context[key] = context; - } - - public: - TraceNode &operator=(const TraceNode &) = delete; - TraceNode(const TraceNode &) = delete; - - bool operator==(TraceNode const &_node) const - { - return this->mPoolIndex == _node.mPoolIndex; - } - - bool operator!=(TraceNode const &_node) const - { - return this->mPoolIndex != _node.mPoolIndex; - } - - public: - void AddTraceDetail(const char *key, const char *v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void AddTraceDetail(const char *key, int v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void AddTraceDetail(const char *key, uint64_t v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void AddTraceDetail(const char *key, Json::Value &v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void appendNodeValue(const char *key, const char *v) - { - std::lock_guard _safe(this->mlock); - this->_value[key].append(v); - } - - public: - void setOpt(const char *opt, va_list *args); - bool checkOpt(); - - private: - void parseOpt(std::string key, std::string value); - - void clearAttach(); - - void initId(NodeID &id); - - inline void resetRelative() - { - this->mNextId = E_INVALID_NODE; - this->mChildHeadId = E_INVALID_NODE; - this->mParentId = mPoolIndex; - this->mRootIndex = mPoolIndex; - this->_subTraceNodeMaxSize = MAX_SUB_TRACE_NODES_LIMIT; - } - - inline void resetStatus() - { - this->fetal_error_time = 0; - this->root_start_time = 0; - this->start_time = 0; - this->limit = E_TRACE_PASS; - this->cumulative_time = 0; - this->mHasExp = false; - } - - public: - // changes: expose _lock - std::mutex mlock; - - public: - int addRef() - { - _mRef++; - return _mRef.load(); - } - - int rmRef() - { - _mRef--; - return _mRef.load(); - } - - bool checkZoreRef() - { - return _mRef.load() == 0; - } - - public: - std::string ToString() - { - std::lock_guard _safe(this->mlock); - char pbuf[1024] = {0}; - int len = snprintf(pbuf, 1024, "mNextId:%d mChildListHeaderId:%d mParentId:%d mRootIndex:%d mPoolIndex:%d \n" - "start_time:%lu,fetal_error_time:%lu,limit:%lu,cumulative_time:%lu,root_start_time:%lu,mHasExp:%d \n" - "_mRef:%d\n" - "_value:%s \n" - "_context size:%lu,_endTraceCallback:%lu \n", - (int)this->mNextId, (int)this->mChildHeadId, (int)this->mParentId, (int)this->mRootIndex, (int)this->mPoolIndex, - this->start_time, this->fetal_error_time, this->limit, this->cumulative_time, this->root_start_time, this->mHasExp, - this->_mRef.load(), - this->_value.toStyledString().c_str(), - this->_context.size(), this->_endTraceCallback.size()); - return std::string(pbuf, len); - } - - private: - std::atomic _mRef; - int _subTraceNodeMaxSize; - - public: - // note: not tls, not a force limitation - inline void updateRootSubTraceSize() - { - if (this->_subTraceNodeMaxSize < 0) - { - throw std::out_of_range("current span reached max sub node limitation"); - } - else - { - this->_subTraceNodeMaxSize--; - } - } - - private: - Json::Value _value; - std::map _context; - std::vector> _endTraceCallback; - }; -} + private: + TraceNode *_traceNode; +}; + +typedef std::shared_ptr _ContextType_; +class TraceNode +{ + public: + NodeID mNextId; // equal brother node + NodeID mChildHeadId; // subtree/child tree + + NodeID mParentId; // parent Id [end_trace] avoiding re-add + NodeID mRootIndex; // highway to root node + NodeID mPoolIndex; + // int64_t mUID; + // int64_t mParentUID; + // int64_t mRootUID; + + uint64_t start_time; + uint64_t fetal_error_time; + uint64_t limit; + uint64_t cumulative_time; + uint64_t root_start_time; + bool mHasExp; + + public: + void startTimer(); + void endTimer(); + void wakeUp(); + + void convertToSpanEvent(); + void convertToSpan(); + + public: + void addChild(WrapperTraceNode &child); + void remove(); + + inline bool isRoot() const { return this->mRootIndex == mPoolIndex; } + + inline bool isLeaf() const { return this->mChildHeadId == E_INVALID_NODE; } + + public: + TraceNode() + { + this->mPoolIndex = E_INVALID_NODE; + this->mRootIndex = E_INVALID_NODE; + this->resetRelative(); + this->resetStatus(); + this->_mRef = 0; + } + + virtual ~TraceNode(); + + TraceNode &reset(NodeID id) + { + std::lock_guard _safe(this->mlock); + this->clearAttach(); + this->initId(id); + this->resetStatus(); + this->resetRelative(); + this->_mRef = 0; + return *this; + } + + NodeID getId() const { return this->mPoolIndex; } + + Json::Value getJsValue() + { + std::lock_guard _safe(this->mlock); + return this->_value; + } + + void getContext(const char *key, std::string &value) + { + std::lock_guard _safe(this->mlock); + _ContextType_ &ctx = this->_context.at(key); + value = ctx->asStringValue(); + } + + void getContext(const char *key, long &value) + { + std::lock_guard _safe(this->mlock); + _ContextType_ &ctx = this->_context.at(key); + value = ctx->asLongValue(); + } + + void setContext(const char *key, const char *buf) + { + std::lock_guard _safe(this->mlock); + _ContextType_ context(std::make_shared(buf)); + this->_context[key] = context; + } + + void setContext(const char *key, long l) + { + std::lock_guard _safe(this->mlock); + _ContextType_ context(std::make_shared(l)); + this->_context[key] = context; + } + + public: + TraceNode &operator=(const TraceNode &) = delete; + TraceNode(const TraceNode &) = delete; + + bool operator==(TraceNode const &_node) const { return this->mPoolIndex == _node.mPoolIndex; } + + bool operator!=(TraceNode const &_node) const { return this->mPoolIndex != _node.mPoolIndex; } + + public: + void AddTraceDetail(const char *key, const char *v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void AddTraceDetail(const char *key, int v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void AddTraceDetail(const char *key, uint64_t v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void AddTraceDetail(const char *key, Json::Value &v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void appendNodeValue(const char *key, const char *v) + { + std::lock_guard _safe(this->mlock); + this->_value[key].append(v); + } + + public: + void setOpt(const char *opt, va_list *args); + bool checkOpt(); + + private: + void parseOpt(std::string key, std::string value); + + void clearAttach(); + + void initId(NodeID &id); + + inline void resetRelative() + { + this->mNextId = E_INVALID_NODE; + this->mChildHeadId = E_INVALID_NODE; + this->mParentId = mPoolIndex; + this->mRootIndex = mPoolIndex; + this->_subTraceNodeMaxSize = MAX_SUB_TRACE_NODES_LIMIT; + } + + inline void resetStatus() + { + this->fetal_error_time = 0; + this->root_start_time = 0; + this->start_time = 0; + this->limit = E_TRACE_PASS; + this->cumulative_time = 0; + this->mHasExp = false; + } + + public: + // changes: expose _lock + std::mutex mlock; + + public: + int addRef() + { + _mRef++; + return _mRef.load(); + } + + int rmRef() + { + _mRef--; + return _mRef.load(); + } + + bool checkZoreRef() { return _mRef.load() == 0; } + + public: + std::string ToString() + { + std::lock_guard _safe(this->mlock); + char pbuf[1024] = {0}; + int len = snprintf(pbuf, 1024, + "mNextId:%d mChildListHeaderId:%d mParentId:%d mRootIndex:%d mPoolIndex:%d \n" + "start_time:%lu,fetal_error_time:%lu,limit:%lu,cumulative_time:%lu,root_start_time:%lu,mHasExp:%d \n" + "_mRef:%d\n" + "_value:%s \n" + "_context size:%lu,_endTraceCallback:%lu \n", + (int) this->mNextId, (int) this->mChildHeadId, (int) this->mParentId, (int) this->mRootIndex, (int) this->mPoolIndex, this->start_time, + this->fetal_error_time, this->limit, this->cumulative_time, this->root_start_time, this->mHasExp, this->_mRef.load(), + this->_value.toStyledString().c_str(), this->_context.size(), this->_endTraceCallback.size()); + return std::string(pbuf, len); + } + + private: + std::atomic _mRef; + int _subTraceNodeMaxSize; + + public: + // note: not tls, not a force limitation + inline void updateRootSubTraceSize() + { + if (this->_subTraceNodeMaxSize < 0) { + throw std::out_of_range("current span reached max sub node limitation"); + } else { + this->_subTraceNodeMaxSize--; + } + } + + private: + Json::Value _value; + std::map _context; + std::vector> _endTraceCallback; +}; +} // namespace NodePool #endif /* COMMON_SRC_TRACENODE_H_ */ diff --git a/common/src/Util/Helper.cpp b/common/src/Util/Helper.cpp index a1b1c630a..b8f9a3992 100644 --- a/common/src/Util/Helper.cpp +++ b/common/src/Util/Helper.cpp @@ -27,94 +27,75 @@ namespace Helper { - namespace Json = AliasJson; - using Cache::NodeTreeWriter; - using NodePool::PoolManager; - - static NodeTreeWriter _writer; - static ConnectionPool::SpanConnectionPool _con_pool; - static std::once_flag _pool_init_flag; - static Json::Value mergeChildren(WrapperTraceNode &node); - uint64_t get_current_msec_stamp() noexcept - { - std::chrono::time_point now = std::chrono::system_clock::now(); - time_point current = time_point_cast(now); - return current.time_since_epoch().count(); - } - - std::string node_tree_to_string(const Json::Value &value) - { - return _writer.write(value); - } - - static void gatcherChildDetailByReverse(Json::Value &detail, WrapperTraceNode &head) - { - if (head->mNextId != E_INVALID_NODE) - { - // TraceNode &next = PoolManager::getInstance().Take(head.mNextId); - WrapperTraceNode next = PoolManager::getInstance().GetWrapperNode(head->mNextId); - gatcherChildDetailByReverse(detail, next); - } - Json::Value childrenDetail = mergeChildren(head); - if (!childrenDetail.empty()) - { - detail.append(childrenDetail); - } - } - - Json::Value mergeChildren(WrapperTraceNode &node) - { - if (node->checkOpt() == false) - { - return Json::Value(); - } - else if (!node->isLeaf()) - { - // TraceNode &child = PoolManager::getInstance().Take(node.mChildHeadIndex); - WrapperTraceNode child = PoolManager::getInstance().GetWrapperNode(node->mChildHeadId); - - Json::Value childTraceDetail; - gatcherChildDetailByReverse(childTraceDetail, child); - node->AddTraceDetail("calls", childTraceDetail); - } - return node->getJsValue(); - } +namespace Json = AliasJson; +using Cache::NodeTreeWriter; +using NodePool::PoolManager; + +static NodeTreeWriter _writer; +static ConnectionPool::SpanConnectionPool _con_pool; +static std::once_flag _pool_init_flag; +static Json::Value mergeChildren(WrapperTraceNode &node); +uint64_t get_current_msec_stamp() noexcept +{ + std::chrono::time_point now = std::chrono::system_clock::now(); + time_point current = time_point_cast(now); + return current.time_since_epoch().count(); +} - Json::Value mergeTraceNodeTree(NodeID Id) noexcept - { - WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(Id); - return mergeTraceNodeTree(root); - } +std::string node_tree_to_string(const Json::Value &value) { return _writer.write(value); } - Json::Value mergeTraceNodeTree(WrapperTraceNode &root) - { - return mergeChildren(root); - } +static void gatcherChildDetailByReverse(Json::Value &detail, WrapperTraceNode &head) +{ + if (head->mNextId != E_INVALID_NODE) { + // TraceNode &next = PoolManager::getInstance().Take(head.mNextId); + WrapperTraceNode next = PoolManager::getInstance().GetWrapperNode(head->mNextId); + gatcherChildDetailByReverse(detail, next); + } + Json::Value childrenDetail = mergeChildren(head); + if (!childrenDetail.empty()) { detail.append(childrenDetail); } +} - Json::Value mergeTraceNodeTree(TraceNode &root) - { - WrapperTraceNode wroot(&root); - return mergeChildren(wroot); - } +Json::Value mergeChildren(WrapperTraceNode &node) +{ + if (node->checkOpt() == false) { + return Json::Value(); + } else if (!node->isLeaf()) { + // TraceNode &child = PoolManager::getInstance().Take(node.mChildHeadIndex); + WrapperTraceNode child = PoolManager::getInstance().GetWrapperNode(node->mChildHeadId); + + Json::Value childTraceDetail; + gatcherChildDetailByReverse(childTraceDetail, child); + node->AddTraceDetail("calls", childTraceDetail); + } + return node->getJsValue(); +} - TransConnection getConnection() - { +Json::Value mergeTraceNodeTree(NodeID Id) noexcept +{ + WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(Id); + return mergeTraceNodeTree(root); +} - std::call_once(_pool_init_flag, - []() - { _con_pool.initPool(global_agent_info.co_host); }); +Json::Value mergeTraceNodeTree(WrapperTraceNode &root) { return mergeChildren(root); } - return _con_pool.get(); - } +Json::Value mergeTraceNodeTree(TraceNode &root) +{ + WrapperTraceNode wroot(&root); + return mergeChildren(wroot); +} - void freeConnection(TransConnection &trans) - { +TransConnection getConnection() +{ + std::call_once(_pool_init_flag, []() { _con_pool.initPool(global_agent_info.co_host); }); - std::call_once(_pool_init_flag, - []() - { _con_pool.initPool(global_agent_info.co_host); }); + return _con_pool.get(); +} - return _con_pool.free(trans); - } +void freeConnection(TransConnection &trans) +{ + std::call_once(_pool_init_flag, []() { _con_pool.initPool(global_agent_info.co_host); }); + return _con_pool.free(trans); } + +} // namespace Helper diff --git a/common/src/common.cpp b/common/src/common.cpp index 451f9499d..54241a240 100644 --- a/common/src/common.cpp +++ b/common/src/common.cpp @@ -45,276 +45,205 @@ using NodePool::WrapperTraceNode; const static char *CLUSE = "clues"; static thread_local NodeID __tls_id = E_ROOT_NODE; -PPAgentT global_agent_info = { - "unix:./pinpoint_test.sock", - 1, - 10, - 1500, - 1, - nullptr, nullptr, nullptr}; +PPAgentT global_agent_info = {"unix:./pinpoint_test.sock", 1, 10, 1500, 1, nullptr, nullptr, nullptr}; // send current span with timeout static thread_local int _span_timeout = global_agent_info.timeout_ms; static std::function _SpanHandler_; -NodeID pinpoint_get_per_thread_id() -{ - return __tls_id; -} +NodeID pinpoint_get_per_thread_id() { return __tls_id; } -void pinpoint_update_per_thread_id(NodeID id) -{ - __tls_id = id; -} +void pinpoint_update_per_thread_id(NodeID id) { __tls_id = id; } static NodeID do_start_trace(NodeID id, const char *opt = nullptr, va_list *args = nullptr) { - if (id <= E_INVALID_NODE) - { - throw std::out_of_range("invalid node id"); - } - else if (id == E_ROOT_NODE) - { - TraceNode &r_node = PoolManager::getInstance().Take(); - r_node.startTimer(); - return r_node.mPoolIndex; - } - else - { - WrapperTraceNode parent = PoolManager::getInstance().GetWrapperNode(id); - - // get root node - WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(parent->mRootIndex); - - root->updateRootSubTraceSize(); - - // todo check subnode limit - WrapperTraceNode trace = PoolManager::getInstance().GetWrapperNode(); - trace->startTimer(); - parent->addChild(trace); - // pass opt - if (opt != nullptr) - { - trace->setOpt(opt, args); - } - return trace->mPoolIndex; - } + if (id <= E_INVALID_NODE) { + throw std::out_of_range("invalid node id"); + } else if (id == E_ROOT_NODE) { + TraceNode &r_node = PoolManager::getInstance().Take(); + r_node.startTimer(); + return r_node.mPoolIndex; + } else { + WrapperTraceNode parent = PoolManager::getInstance().GetWrapperNode(id); + + // get root node + WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(parent->mRootIndex); + + root->updateRootSubTraceSize(); + + // todo check subnode limit + WrapperTraceNode trace = PoolManager::getInstance().GetWrapperNode(); + trace->startTimer(); + parent->addChild(trace); + // pass opt + if (opt != nullptr) { trace->setOpt(opt, args); } + return trace->mPoolIndex; + } } static void flush_to_agent(std::string &span) { - TransConnection trans = Helper::getConnection(); + TransConnection trans = Helper::getConnection(); - if (!trans->copy_into_send_buffer(span)) - { - pp_trace("drop current span as it's too heavy! size:%lu", span.length()); - } - trans->trans_layer_pool(_span_timeout); - // if network not ready, span will send in next time. - Helper::freeConnection(trans); + if (!trans->copy_into_send_buffer(span)) { pp_trace("drop current span as it's too heavy! size:%lu", span.length()); } + trans->trans_layer_pool(_span_timeout); + // if network not ready, span will send in next time. + Helper::freeConnection(trans); } void sendSpan(NodeID rootId) { - const Json::Value trace = Helper::mergeTraceNodeTree(rootId); - std::string spanStr = Helper::node_tree_to_string(trace); - if (unlikely(_SpanHandler_ != nullptr)) - { - _SpanHandler_(spanStr.c_str()); - } - else - { - pp_trace("this span:(%s)", spanStr.c_str()); - flush_to_agent(spanStr); - } + const Json::Value trace = Helper::mergeTraceNodeTree(rootId); + std::string spanStr = Helper::node_tree_to_string(trace); + if (unlikely(_SpanHandler_ != nullptr)) { + _SpanHandler_(spanStr.c_str()); + } else { + pp_trace("this span:(%s)", spanStr.c_str()); + flush_to_agent(spanStr); + } } NodeID do_end_trace(NodeID Id) { - WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(Id); - if (r_node->isRoot()) - { - if (r_node->limit == E_TRACE_PASS) - { - r_node->endTimer(); - r_node->convertToSpan(); - sendSpan(Id); - } - else if (r_node->limit == E_TRACE_BLOCK) - { - pp_trace("current#%d span dropped,due to TRACE_BLOCK", r_node->getId()); - } - else - { - pp_trace("current#%d span dropped,due to limit=%ld", r_node->getId(), r_node->limit); - } - } - else - { - r_node->endTimer(); - r_node->convertToSpanEvent(); - return r_node->mParentId; - // check opt - // if (r_node->checkOpt() == true) - // { - // try - // { - // WrapperTraceNode r_parent = PoolManager::getInstance().GetWrapperNode(parentId); - // r_parent->addChild(r_node); - // return r_parent->mPoolIndex; - // } - // catch (const std::out_of_range &ex) - // { - // pp_trace("current#%d dropped,due to parent is end", Id); - // } - // catch (const std::exception &ex) - // { - // pp_trace("current#%d dropped,due to exception: %s", Id, ex.what()); - // } - // } - // else - // { - // pp_trace("current#%d dropped,due to checkOpt false", Id); - // } - } - // free current ndde tree - return E_ROOT_NODE; + WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(Id); + if (r_node->isRoot()) { + if (r_node->limit == E_TRACE_PASS) { + r_node->endTimer(); + r_node->convertToSpan(); + sendSpan(Id); + } else if (r_node->limit == E_TRACE_BLOCK) { + pp_trace("current#%d span dropped,due to TRACE_BLOCK", r_node->getId()); + } else { + pp_trace("current#%d span dropped,due to limit=%ld", r_node->getId(), r_node->limit); + } + } else { + r_node->endTimer(); + r_node->convertToSpanEvent(); + return r_node->mParentId; + // check opt + // if (r_node->checkOpt() == true) + // { + // try + // { + // WrapperTraceNode r_parent = PoolManager::getInstance().GetWrapperNode(parentId); + // r_parent->addChild(r_node); + // return r_parent->mPoolIndex; + // } + // catch (const std::out_of_range &ex) + // { + // pp_trace("current#%d dropped,due to parent is end", Id); + // } + // catch (const std::exception &ex) + // { + // pp_trace("current#%d dropped,due to exception: %s", Id, ex.what()); + // } + // } + // else + // { + // pp_trace("current#%d dropped,due to checkOpt false", Id); + // } + } + // free current ndde tree + return E_ROOT_NODE; } NodeID pinpoint_start_trace(NodeID parentId) { - try - { - NodeID childId = do_start_trace(parentId); - pp_trace("#%d pinpoint_start child #%d", parentId, childId); - return childId; - } - catch (const std::out_of_range &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - return E_INVALID_NODE; + try { + NodeID childId = do_start_trace(parentId); + pp_trace("#%d pinpoint_start child #%d", parentId, childId); + return childId; + } catch (const std::out_of_range &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } + return E_INVALID_NODE; } static NodeID do_wake_trace(NodeID &id) { - // routine - // 1. check id alive - // 2. check if it's a root node - // 3. update start time + // routine + // 1. check id alive + // 2. check if it's a root node + // 3. update start time - WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(id); + WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(id); - if (w_node->isRoot()) - { - pp_trace("#%d wake_trace failed, it's a root node", id); - return E_INVALID_NODE; - } + if (w_node->isRoot()) { + pp_trace("#%d wake_trace failed, it's a root node", id); + return E_INVALID_NODE; + } - w_node->wakeUp(); + w_node->wakeUp(); - return id; + return id; } int pinpoint_wake_trace(NodeID traceId) { - try - { - pp_trace("wake_trace #%d ", traceId); - return do_wake_trace(traceId); - } - catch (const std::out_of_range &ex) - { - pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); - } - catch (...) - { - pp_trace(" wake_trace#%d failed with unkonw reason", traceId); - } - return 0; + try { + pp_trace("wake_trace #%d ", traceId); + return do_wake_trace(traceId); + } catch (const std::out_of_range &ex) { + pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); + } catch (...) { + pp_trace(" wake_trace#%d failed with unkonw reason", traceId); + } + return 0; } int pinpoint_force_end_trace(NodeID id, int32_t timeout) { - try - { - _span_timeout = timeout; - while (id != E_ROOT_NODE) - { - id = pinpoint_end_trace(id); - if (id == E_INVALID_NODE) - break; - } - // back to normal - _span_timeout = global_agent_info.timeout_ms; - return 0; - } - catch (const std::out_of_range &) - { - pp_trace("#%d not found", id); + try { + _span_timeout = timeout; + while (id != E_ROOT_NODE) { + id = pinpoint_end_trace(id); + if (id == E_INVALID_NODE) break; } - catch (const std::exception &ex) - { - pp_trace("#%d end trace failed. %s", id, ex.what()); - } - return -1; + // back to normal + _span_timeout = global_agent_info.timeout_ms; + return 0; + } catch (const std::out_of_range &) { + pp_trace("#%d not found", id); + } catch (const std::exception &ex) { + pp_trace("#%d end trace failed. %s", id, ex.what()); + } + return -1; } int pinpoint_trace_is_root(NodeID _id) { - try - { - WrapperTraceNode node = PoolManager::getInstance().GetWrapperNode(_id); - return node->isRoot() ? (1) : (0); - } - catch (const std::out_of_range &) - { - pp_trace("#%d not found", _id); - } - catch (const std::exception &ex) - { - pp_trace("#%d end trace failed. %s", _id, ex.what()); - } - return -1; + try { + WrapperTraceNode node = PoolManager::getInstance().GetWrapperNode(_id); + return node->isRoot() ? (1) : (0); + } catch (const std::out_of_range &) { + pp_trace("#%d not found", _id); + } catch (const std::exception &ex) { + pp_trace("#%d end trace failed. %s", _id, ex.what()); + } + return -1; } NodeID pinpoint_end_trace(NodeID traceId) { - try - { - NodeID ret = do_end_trace(traceId); - if (ret == E_ROOT_NODE) - { - freeNodeTree(traceId); - } - pp_trace("#%d pinpoint_end_trace Done!", traceId); - return ret; - } - catch (const std::out_of_range &ex) - { - pp_trace("end_trace %d out_of_range exception: %s", traceId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace("end_trace %d runtime_error: %s", traceId, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace("end_trace #%d end trace failed. %s", traceId, ex.what()); - } + try { + NodeID ret = do_end_trace(traceId); + if (ret == E_ROOT_NODE) { freeNodeTree(traceId); } + pp_trace("#%d pinpoint_end_trace Done!", traceId); + return ret; + } catch (const std::out_of_range &ex) { + pp_trace("end_trace %d out_of_range exception: %s", traceId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace("end_trace %d runtime_error: %s", traceId, ex.what()); + } catch (const std::exception &ex) { + pp_trace("end_trace #%d end trace failed. %s", traceId, ex.what()); + } - return E_INVALID_NODE; + return E_INVALID_NODE; } // static int do_remove_trace(NodeID traceId) @@ -340,379 +269,280 @@ NodeID pinpoint_end_trace(NodeID traceId) // } // } -uint64_t pinpoint_start_time(void) -{ - return (uint64_t)SafeSharedState::instance().getStartTime(); -} +uint64_t pinpoint_start_time(void) { return (uint64_t) SafeSharedState::instance().getStartTime(); } -int64_t generate_unique_id() -{ - return SafeSharedState::instance().generateUniqueId(); -} +int64_t generate_unique_id() { return SafeSharedState::instance().generateUniqueId(); } -void reset_unique_id(void) -{ - - return SafeSharedState::instance().resetUniqueId(); -} +void reset_unique_id(void) { return SafeSharedState::instance().resetUniqueId(); } uint64_t inline do_mark_current_trace_status(NodeID &_id, E_AGENT_STATUS status) { - WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); - WrapperTraceNode w_root = PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); - pp_trace("change current#%d status, before:%lld,now:%d", w_root->getId(), w_root->limit, status); - return __sync_lock_test_and_set(&w_root->limit, status); + WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); + WrapperTraceNode w_root = PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); + pp_trace("change current#%d status, before:%lld,now:%d", w_root->getId(), w_root->limit, status); + return __sync_lock_test_and_set(&w_root->limit, status); } uint64_t mark_current_trace_status(NodeID _id, int status) { - try - { - return do_mark_current_trace_status(_id, (E_AGENT_STATUS)status); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (...) - { - pp_trace(" %s#%d failed with unkonw reason", __func__, _id); - } - return 0; + try { + return do_mark_current_trace_status(_id, (E_AGENT_STATUS) status); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (...) { + pp_trace(" %s#%d failed with unkonw reason", __func__, _id); + } + return 0; } -int check_tracelimit(int64_t timestamp) -{ - return SafeSharedState::instance().checkTraceLimit(timestamp) ? (1) : (0); -} +int check_tracelimit(int64_t timestamp) { return SafeSharedState::instance().checkTraceLimit(timestamp) ? (1) : (0); } static inline WrapperTraceNode locate_node_by_loc(NodeID _id, E_NODE_LOC flag) { - WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); - if (flag == E_LOC_ROOT) - { - return PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); - } - else - { - return w_node; - } + WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); + if (flag == E_LOC_ROOT) { + return PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); + } else { + return w_node; + } } static void do_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - WrapperTraceNode w_node = locate_node_by_loc(_id, flag); - w_node->AddTraceDetail(key, value); - pp_trace("#%d add clue key:%s value:%s", _id, key, value); + WrapperTraceNode w_node = locate_node_by_loc(_id, flag); + w_node->AddTraceDetail(key, value); + pp_trace("#%d add clue key:%s value:%s", _id, key, value); } static void do_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - WrapperTraceNode w_node = locate_node_by_loc(_id, flag); + WrapperTraceNode w_node = locate_node_by_loc(_id, flag); - std::string cvalue = ""; - cvalue += key; - cvalue += ':'; - cvalue += value; - w_node->appendNodeValue(CLUSE, cvalue.c_str()); - pp_trace("#%d add clues:%s:%s", _id, key, value); + std::string cvalue = ""; + cvalue += key; + cvalue += ':'; + cvalue += value; + w_node->appendNodeValue(CLUSE, cvalue.c_str()); + pp_trace("#%d add clues:%s:%s", _id, key, value); } void pinpoint_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - try - { - do_add_clues(_id, key, value, flag); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (...) - { - pp_trace(" %s#%d failed.Reason: unknown reason,parameters:%s:%s", __func__, _id, key, value); - } + try { + do_add_clues(_id, key, value, flag); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (...) { + pp_trace(" %s#%d failed.Reason: unknown reason,parameters:%s:%s", __func__, _id, key, value); + } } void pinpoint_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - try - { - do_add_clue(_id, key, value, flag); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (...) - { - pp_trace(" %s#%d failed. Reason: unknow reason,parameters:%s:%s", __func__, _id, key, value); - } + try { + do_add_clue(_id, key, value, flag); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (...) { + pp_trace(" %s#%d failed. Reason: unknow reason,parameters:%s:%s", __func__, _id, key, value); + } } static inline void do_set_context_key(NodeID _id, const char *key, const char *value) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - w_node->setContext(key, value); + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + w_node->setContext(key, value); } static int do_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - std::string value; - w_node->getContext(key, value); - if (pbuf != nullptr && buf_size > (int)value.size()) - { - strncpy(pbuf, value.c_str(), buf_size); - return (int)value.size(); - } - else - { - pp_trace("#%d get context key:%s failed. buffer is not enough", _id, key); - return -1; - } + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + std::string value; + w_node->getContext(key, value); + if (pbuf != nullptr && buf_size > (int) value.size()) { + strncpy(pbuf, value.c_str(), buf_size); + return (int) value.size(); + } else { + pp_trace("#%d get context key:%s failed. buffer is not enough", _id, key); + return -1; + } } void pinpoint_set_context_key(NodeID _id, const char *key, const char *value) { - try - { - do_set_context_key(_id, key, value); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with out_of_range. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with runtime_error. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } + try { + do_set_context_key(_id, key, value); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with out_of_range. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with runtime_error. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } } static void do_set_long_key(NodeID id, const char *key, long l) { - WrapperTraceNode w_node = locate_node_by_loc(id, E_LOC_ROOT); - w_node->setContext(key, l); + WrapperTraceNode w_node = locate_node_by_loc(id, E_LOC_ROOT); + w_node->setContext(key, l); } void pinpoint_set_context_long(NodeID _id, const char *key, long l) { - try - { - do_set_long_key(_id, key, l); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } + try { + do_set_long_key(_id, key, l); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } } static int do_get_long_key(NodeID _id, const char *key, long *l) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - if (l != nullptr) - { - long v; - w_node->getContext(key, v); - *l = v; - } - return 0; + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + if (l != nullptr) { + long v; + w_node->getContext(key, v); + *l = v; + } + return 0; } int pinpoint_get_context_long(NodeID _id, const char *key, long *l) { - try - { - do_get_long_key(_id, key, l); - return 0; - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - return 1; + try { + do_get_long_key(_id, key, l); + return 0; + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } + return 1; } int pinpoint_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size) { - try - { - return do_get_context_key(_id, key, pbuf, buf_size); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); - } - return -1; + try { + return do_get_context_key(_id, key, pbuf, buf_size); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); + } + return -1; } void do_catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - Json::Value eMsg; - eMsg["msg"] = msg; - eMsg["file"] = error_filename; - eMsg["line"] = error_lineno; - w_node->AddTraceDetail("ERR", eMsg); + Json::Value eMsg; + eMsg["msg"] = msg; + eMsg["file"] = error_filename; + eMsg["line"] = error_lineno; + w_node->AddTraceDetail("ERR", eMsg); } void catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno) { - try - { - do_catch_error(_id, msg, error_filename, error_lineno); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } + try { + do_catch_error(_id, msg, error_filename, error_lineno); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } } const char *pinpoint_agent_version() { #ifdef AGENT_VERSION - static const char *_version_ = AGENT_VERSION; + static const char *_version_ = AGENT_VERSION; #else - static const char *_version_ = "x.x.x"; + static const char *_version_ = "x.x.x"; #endif - return _version_; + return _version_; } NodeID pinpoint_start_traceV1(NodeID parentId, const char *opt, ...) { - try - { - va_list args; - va_start(args, opt); - NodeID childId = do_start_trace(parentId, opt, &args); - va_end(args); - pp_trace("#%d pinpoint_start_traceV1 child #%d", parentId, childId); - return childId; - } - catch (const std::out_of_range &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (...) - { - pp_trace(" start_trace#%d failed with unkonw reason", parentId); - } - return E_INVALID_NODE; + try { + va_list args; + va_start(args, opt); + NodeID childId = do_start_trace(parentId, opt, &args); + va_end(args); + pp_trace("#%d pinpoint_start_traceV1 child #%d", parentId, childId); + return childId; + } catch (const std::out_of_range &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (...) { + pp_trace(" start_trace#%d failed with unkonw reason", parentId); + } + return E_INVALID_NODE; } static void do_add_exp(NodeID _id, const char *value) { - WrapperTraceNode w_root = locate_node_by_loc(_id, E_LOC_CURRENT); - w_root->AddTraceDetail("EXP", value); - w_root->mHasExp = true; - pp_trace("#%d add exp value:%s", _id, value); + WrapperTraceNode w_root = locate_node_by_loc(_id, E_LOC_CURRENT); + w_root->AddTraceDetail("EXP", value); + w_root->mHasExp = true; + pp_trace("#%d add exp value:%s", _id, value); } void pinpoint_add_exception(NodeID traceId, const char *exp) { - try - { - do_add_exp(traceId, exp); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); - } + try { + do_add_exp(traceId, exp); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); + } } void register_span_handler(void (*handler)(const char *)) { - if (likely(handler != nullptr)) - { - _SpanHandler_ = std::bind(handler, std::placeholders::_1); - } + if (likely(handler != nullptr)) { _SpanHandler_ = std::bind(handler, std::placeholders::_1); } } void show_status(void) { - Json::Value status; - status["pool_total_node"] = PoolManager::getInstance().totoalNodesCount(); - status["pool_free_node"] = PoolManager::getInstance().freeNodesCount(); - status["common_libary_version"] = pinpoint_agent_version(); - auto add_alive_node_fun = [&status](TraceNode &node) - { - status["pool_alive_nodes"].append(node.mPoolIndex); - }; - PoolManager::getInstance().foreachAliveNode(std::bind(add_alive_node_fun, std::placeholders::_1)); + Json::Value status; + status["pool_total_node"] = PoolManager::getInstance().totoalNodesCount(); + status["pool_free_node"] = PoolManager::getInstance().freeNodesCount(); + status["common_libary_version"] = pinpoint_agent_version(); + auto add_alive_node_fun = [&status](TraceNode &node) { status["pool_alive_nodes"].append(node.mPoolIndex); }; + PoolManager::getInstance().foreachAliveNode(std::bind(add_alive_node_fun, std::placeholders::_1)); - fprintf(stderr, "%s\n", status.toStyledString().c_str()); + fprintf(stderr, "%s\n", status.toStyledString().c_str()); } void debug_nodeid(NodeID id) { - try - { - WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(id); - fprintf(stderr, "nodeid#%d: { value:%s }", id, r_node->ToString().c_str()); - } - catch (const std::exception &ex) - { - pp_trace(" debug_nodeid:#%d Reason: %s", id, ex.what()); - } + try { + WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(id); + fprintf(stderr, "nodeid#%d: { value:%s }", id, r_node->ToString().c_str()); + } catch (const std::exception &ex) { + pp_trace(" debug_nodeid:#%d Reason: %s", id, ex.what()); + } } \ No newline at end of file diff --git a/common/test/test_chunk.cc b/common/test/test_chunk.cc index 742630eb2..1cd0f3cd4 100644 --- a/common/test/test_chunk.cc +++ b/common/test/test_chunk.cc @@ -4,62 +4,61 @@ using namespace testing; using Cache::Chunks; -static int checkData(const void* buf,uint length,void* dst) +static int checkData(const void* buf, uint length, void* dst) { - int ret = 0; - if(length < 25) - { - ret = length; - }else{ - ret = length /2; - } - std::string * str = (std::string*)dst; - str->append((const char*)buf,ret); + int ret = 0; + if (length < 25) { + ret = length; + } else { + ret = length / 2; + } + std::string* str = (std::string*) dst; + str->append((const char*) buf, ret); - return ret; + return ret; } TEST(chunk, all_in_one) { - Chunks chunks(1024*4,128); - std::string out,ret; -// int size = 0; - // user random data - char buf1[1024]; - char buf2[1024]; - char buf3[1024]; + Chunks chunks(1024 * 4, 128); + std::string out, ret; + // int size = 0; + // user random data + char buf1[1024]; + char buf2[1024]; + char buf3[1024]; - chunks.copyDataIntoChunks(buf1,1024); - chunks.copyDataIntoChunks(buf2,1024); - chunks.copyDataIntoChunks(buf3,1024); - out.append(buf1,1024); - out.append(buf2,1024); - out.append(buf3,1024); + chunks.copyDataIntoChunks(buf1, 1024); + chunks.copyDataIntoChunks(buf2, 1024); + chunks.copyDataIntoChunks(buf3, 1024); + out.append(buf1, 1024); + out.append(buf2, 1024); + out.append(buf3, 1024); - // in and out - chunks.drainOutWithPipe(std::bind(&checkData,std::placeholders::_1,std::placeholders::_2,&ret)); + // in and out + chunks.drainOutWithPipe(std::bind(&checkData, std::placeholders::_1, std::placeholders::_2, &ret)); - EXPECT_TRUE(ret == out); + EXPECT_TRUE(ret == out); - // copy until full - chunks.copyDataIntoChunks(buf1,1024); - chunks.copyDataIntoChunks(buf2,1024); - chunks.copyDataIntoChunks(buf3,1024); - EXPECT_FALSE(chunks.checkCapacity(1025)); + // copy until full + chunks.copyDataIntoChunks(buf1, 1024); + chunks.copyDataIntoChunks(buf2, 1024); + chunks.copyDataIntoChunks(buf3, 1024); + EXPECT_FALSE(chunks.checkCapacity(1025)); - chunks.copyDataIntoChunks(buf3,1024); - EXPECT_TRUE(chunks.copyDataIntoChunks(buf3,1024) == 0 ); + chunks.copyDataIntoChunks(buf3, 1024); + EXPECT_TRUE(chunks.copyDataIntoChunks(buf3, 1024) == 0); - out.clear(); - out.append(buf1,1024); - out.append(buf2,1024); - out.append(buf3,1024); - out.append(buf3,1024); - out.append(buf3,1024); + out.clear(); + out.append(buf1, 1024); + out.append(buf2, 1024); + out.append(buf3, 1024); + out.append(buf3, 1024); + out.append(buf3, 1024); - ret.clear(); - chunks.drainOutWithPipe(std::bind(&checkData,std::placeholders::_1,std::placeholders::_2,&ret)); - EXPECT_TRUE(chunks.getAllocSize() == 0); - EXPECT_TRUE(ret == out); + ret.clear(); + chunks.drainOutWithPipe(std::bind(&checkData, std::placeholders::_1, std::placeholders::_2, &ret)); + EXPECT_TRUE(chunks.getAllocSize() == 0); + EXPECT_TRUE(ret == out); } diff --git a/common/test/test_common.cc b/common/test/test_common.cc index 1c5d517cc..916082ef8 100644 --- a/common/test/test_common.cc +++ b/common/test/test_common.cc @@ -8,181 +8,167 @@ using namespace testing; std::string ouputMsg; -void cc_log_error_cb(char *msg) -{ - ouputMsg += msg; -} +void cc_log_error_cb(char *msg) { ouputMsg += msg; } TEST(common, uid_all_in_one) { - // register_error_cb(cc_log_error_cb); - // test_trace(); - int64_t startId = generate_unique_id(); - generate_unique_id(); - generate_unique_id(); - generate_unique_id(); - EXPECT_EQ(generate_unique_id(), 4 + startId); + // register_error_cb(cc_log_error_cb); + // test_trace(); + int64_t startId = generate_unique_id(); + generate_unique_id(); + generate_unique_id(); + generate_unique_id(); + EXPECT_EQ(generate_unique_id(), 4 + startId); #define _100K 100000 - pid_t pid = fork(); - if (pid == 0) - { - for (int i = 0; i < _100K; i++) - generate_unique_id(); - exit(0); - } - - for (int i = 0; i < _100K; i++) - generate_unique_id(); - waitpid(pid, NULL, 0); - //[0~9999] - EXPECT_EQ(generate_unique_id(), (startId + 2 * _100K + 5)); + pid_t pid = fork(); + if (pid == 0) { + for (int i = 0; i < _100K; i++) generate_unique_id(); + exit(0); + } + + for (int i = 0; i < _100K; i++) generate_unique_id(); + waitpid(pid, NULL, 0); + //[0~9999] + EXPECT_EQ(generate_unique_id(), (startId + 2 * _100K + 5)); } TEST(common, start_end_trace) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - mark_current_trace_status(id, E_OFFLINE); - EXPECT_EQ(pinpoint_trace_is_root(id), 1); - id = pinpoint_start_trace(id); - EXPECT_EQ(pinpoint_trace_is_root(id), 0); - mark_current_trace_status(id, E_OFFLINE); - EXPECT_EQ(pinpoint_trace_is_root(NodeID(-1023)), -1); - EXPECT_EQ(pinpoint_trace_is_root(NodeID(1023)), -1); - id = pinpoint_start_trace(id); - - mark_current_trace_status(id, E_TRACE_PASS); - catch_error(id, "sdfasfas", "fsafdsfasd", 234); - id = pinpoint_end_trace(id); - - id = pinpoint_end_trace(id); - - id = pinpoint_end_trace(id); - EXPECT_EQ(id, 0); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + mark_current_trace_status(id, E_OFFLINE); + EXPECT_EQ(pinpoint_trace_is_root(id), 1); + id = pinpoint_start_trace(id); + EXPECT_EQ(pinpoint_trace_is_root(id), 0); + mark_current_trace_status(id, E_OFFLINE); + EXPECT_EQ(pinpoint_trace_is_root(NodeID(-1023)), -1); + EXPECT_EQ(pinpoint_trace_is_root(NodeID(1023)), -1); + id = pinpoint_start_trace(id); + + mark_current_trace_status(id, E_TRACE_PASS); + catch_error(id, "sdfasfas", "fsafdsfasd", 234); + id = pinpoint_end_trace(id); + + id = pinpoint_end_trace(id); + + id = pinpoint_end_trace(id); + EXPECT_EQ(id, 0); } TEST(common, context_check) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - std::string str = "fdafadf"; - pinpoint_add_clues(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - - id = pinpoint_start_trace(id); - pinpoint_add_clue(id, "global", str.c_str(), E_LOC_ROOT); - id = pinpoint_end_trace(id); - str.clear(); - str = "fadfaffadf"; - pinpoint_set_context_key(id, "adfadf", str.c_str()); - str += "35486we32"; - pinpoint_set_context_key(id, "adfadf23", str.c_str()); - str.clear(); - char buf[1024] = {0}; - pinpoint_get_context_key(id, "adfadf23", buf, 1024); - - EXPECT_STREQ(buf, "fadfaffadf35486we32"); - pinpoint_get_context_key(id, "adfadf", buf, 1024); - - EXPECT_STREQ(buf, "fadfaffadf"); - - pinpoint_set_context_long(id, "1024", 1024); - pinpoint_set_context_long(NodeID(0), "1024", 1024); - pinpoint_set_context_long(NodeID(1205), "1024", 1024); - pinpoint_set_context_key(id, "adfadf23", "fadfaffadf"); - long value; - EXPECT_EQ(pinpoint_get_context_long(id, "1024", &value), 0); - EXPECT_EQ(value, 1024); - pinpoint_end_trace(id); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + std::string str = "fdafadf"; + pinpoint_add_clues(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + + id = pinpoint_start_trace(id); + pinpoint_add_clue(id, "global", str.c_str(), E_LOC_ROOT); + id = pinpoint_end_trace(id); + str.clear(); + str = "fadfaffadf"; + pinpoint_set_context_key(id, "adfadf", str.c_str()); + str += "35486we32"; + pinpoint_set_context_key(id, "adfadf23", str.c_str()); + str.clear(); + char buf[1024] = {0}; + pinpoint_get_context_key(id, "adfadf23", buf, 1024); + + EXPECT_STREQ(buf, "fadfaffadf35486we32"); + pinpoint_get_context_key(id, "adfadf", buf, 1024); + + EXPECT_STREQ(buf, "fadfaffadf"); + + pinpoint_set_context_long(id, "1024", 1024); + pinpoint_set_context_long(NodeID(0), "1024", 1024); + pinpoint_set_context_long(NodeID(1205), "1024", 1024); + pinpoint_set_context_key(id, "adfadf23", "fadfaffadf"); + long value; + EXPECT_EQ(pinpoint_get_context_long(id, "1024", &value), 0); + EXPECT_EQ(value, 1024); + pinpoint_end_trace(id); } TEST(common, error_checking) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - EXPECT_EQ(pinpoint_trace_is_root(id), 1); - id = pinpoint_end_trace(id); - EXPECT_EQ(id, 0); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + EXPECT_EQ(pinpoint_trace_is_root(id), 1); + id = pinpoint_end_trace(id); + EXPECT_EQ(id, 0); - id = pinpoint_start_trace(NodeID(1280)); - EXPECT_EQ(id, E_INVALID_NODE); + id = pinpoint_start_trace(NodeID(1280)); + EXPECT_EQ(id, E_INVALID_NODE); } static void test_per_thread_id_odd() { - NodeID id = pinpoint_get_per_thread_id(); - EXPECT_EQ(id, 0); - id = NodeID(1); - for (int i = 1; i < 10000; i++) - { - int index = (int)id; - index += 2; - id = NodeID(index); - pinpoint_update_per_thread_id(id); - std::this_thread::sleep_for(std::chrono::microseconds(1)); - EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2 + 1); - } + NodeID id = pinpoint_get_per_thread_id(); + EXPECT_EQ(id, 0); + id = NodeID(1); + for (int i = 1; i < 10000; i++) { + int index = (int) id; + index += 2; + id = NodeID(index); + pinpoint_update_per_thread_id(id); + std::this_thread::sleep_for(std::chrono::microseconds(1)); + EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2 + 1); + } } static void test_per_thread_id_even() { - NodeID id = pinpoint_get_per_thread_id(); - EXPECT_EQ(id, 0); - - for (int i = 1; i < 10000; i++) - { - int index = (int)id; - index += 2; - id = (NodeID)index; - - pinpoint_update_per_thread_id(id); - std::this_thread::sleep_for(std::chrono::microseconds(1)); - EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2); - } + NodeID id = pinpoint_get_per_thread_id(); + EXPECT_EQ(id, 0); + + for (int i = 1; i < 10000; i++) { + int index = (int) id; + index += 2; + id = (NodeID) index; + + pinpoint_update_per_thread_id(id); + std::this_thread::sleep_for(std::chrono::microseconds(1)); + EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2); + } } TEST(common, per_threadid) { - std::thread f1(test_per_thread_id_odd); - std::thread f2(test_per_thread_id_even); - f1.join(); - f2.join(); + std::thread f1(test_per_thread_id_odd); + std::thread f2(test_per_thread_id_even); + f1.join(); + f2.join(); } TEST(common, force_end_trace) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - id = pinpoint_end_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_end_trace(id); - id = pinpoint_end_trace(id); - EXPECT_NE(id, 0); - int ret = pinpoint_force_end_trace(id, 300); - EXPECT_EQ(ret, 0); - id = NodeID(809999); - pinpoint_force_end_trace(id, 300); - pinpoint_force_end_trace(NodeID(-1235), 300); - pinpoint_force_end_trace(NodeID(0), 300); - pinpoint_force_end_trace(NodeID(1), 300); - pinpoint_force_end_trace(NodeID(-1), 300); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + id = pinpoint_end_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_end_trace(id); + id = pinpoint_end_trace(id); + EXPECT_NE(id, 0); + int ret = pinpoint_force_end_trace(id, 300); + EXPECT_EQ(ret, 0); + id = NodeID(809999); + pinpoint_force_end_trace(id, 300); + pinpoint_force_end_trace(NodeID(-1235), 300); + pinpoint_force_end_trace(NodeID(0), 300); + pinpoint_force_end_trace(NodeID(1), 300); + pinpoint_force_end_trace(NodeID(-1), 300); } -TEST(common, version) -{ - EXPECT_STREQ(pinpoint_agent_version(), AGENT_VERSION); -} +TEST(common, version) { EXPECT_STREQ(pinpoint_agent_version(), AGENT_VERSION); } //./bin/unittest --gtest_filter=common.id_1 TEST(common, id_1) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - for (int i = 0; i < 1280; i++) - { - id = pinpoint_start_trace(id); - } - pinpoint_set_context_long(id, "1024", 1024); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + for (int i = 0; i < 1280; i++) { id = pinpoint_start_trace(id); } + pinpoint_set_context_long(id, "1024", 1024); } diff --git a/common/test/test_genUniqId.cc b/common/test/test_genUniqId.cc index 40237a65c..4e9cdd0c9 100644 --- a/common/test/test_genUniqId.cc +++ b/common/test/test_genUniqId.cc @@ -7,37 +7,35 @@ using namespace testing; -TEST(common,unique_id) +TEST(common, unique_id) { - static const int TIMES=10000000; - int64_t last=-1; - // reset the unique id - reset_unique_id(); - pid_t pid = fork(); - if(pid == 0){ // child - for(int i=0;i #include "common.h" -void remove_shm_file() -{ - shm_unlink("pinpoint-php.shm"); -} +void remove_shm_file() { shm_unlink("pinpoint-php.shm"); } int main(int argc, char **argv) { - std::atexit(remove_shm_file); - register_error_cb(NULL); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + std::atexit(remove_shm_file); + register_error_cb(NULL); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/common/test/test_node.cc b/common/test/test_node.cc index 1a0cfbd86..4d9abf046 100644 --- a/common/test/test_node.cc +++ b/common/test/test_node.cc @@ -18,409 +18,381 @@ std::mutex cv_m; std::condition_variable cv; NodeID rootId = E_ROOT_NODE; -int usedNode() -{ - return PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); -} +int usedNode() { return PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); } // note: as it known, there may leak some node void func() { - std::unique_lock lk(cv_m); - cv.wait(lk); - pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); - pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); - for (int i = 0; i < 100; ++i) - { - rootId = pinpoint_start_trace(rootId); - pinpoint_set_context_key(rootId, "xxxx", "bbbbbb"); - std::this_thread::yield(); - char buf[1024]; - pinpoint_get_context_key(rootId, "xxxx", buf, 1024); - std::cout << "read value:" << buf << " "; - pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); - std::this_thread::yield(); - pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); - std::this_thread::yield(); - rootId = pinpoint_end_trace(rootId); - std::this_thread::yield(); - } + std::unique_lock lk(cv_m); + cv.wait(lk); + pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); + pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); + for (int i = 0; i < 100; ++i) { + rootId = pinpoint_start_trace(rootId); + pinpoint_set_context_key(rootId, "xxxx", "bbbbbb"); + std::this_thread::yield(); + char buf[1024]; + pinpoint_get_context_key(rootId, "xxxx", buf, 1024); + std::cout << "read value:" << buf << " "; pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); + std::this_thread::yield(); pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); + std::this_thread::yield(); + rootId = pinpoint_end_trace(rootId); + std::this_thread::yield(); + } + pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); + pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); } TEST(node, multipleThread) { - // no crash, works fine - NodeID root = pinpoint_start_trace(E_ROOT_NODE); + // no crash, works fine + NodeID root = pinpoint_start_trace(E_ROOT_NODE); - std::vector threads; + std::vector threads; - for (int i = 0; i < 10; i++) - { - threads.push_back(std::thread(func)); - } + for (int i = 0; i < 10; i++) { threads.push_back(std::thread(func)); } - sleep(2); - cv.notify_all(); + sleep(2); + cv.notify_all(); - for (int i = 0; i < 10; i++) - { - threads[i].join(); - } - pinpoint_end_trace(root); - pinpoint_end_trace(root); - // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); + for (int i = 0; i < 10; i++) { threads[i].join(); } + pinpoint_end_trace(root); + pinpoint_end_trace(root); + // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); } TEST(node, wakeTrace) { - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - NodeID child1 = pinpoint_start_trace(root); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + NodeID child1 = pinpoint_start_trace(root); - pinpoint_end_trace(child1); + pinpoint_end_trace(child1); - pinpoint_wake_trace(child1); - pinpoint_wake_trace(root); - pinpoint_wake_trace(NodeID(159)); - pinpoint_wake_trace(NodeID(1027)); - // do something - sleep(1); - pinpoint_end_trace(child1); + pinpoint_wake_trace(child1); + pinpoint_wake_trace(root); + pinpoint_wake_trace(NodeID(159)); + pinpoint_wake_trace(NodeID(1027)); + // do something + sleep(1); + pinpoint_end_trace(child1); - pinpoint_end_trace(root); - // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); + pinpoint_end_trace(root); + // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); } void test_opt(TraceNode &node, const char *opt, ...) { - va_list args; - va_start(args, opt); - node.setOpt(opt, &args); - va_end(args); + va_list args; + va_start(args, opt); + node.setOpt(opt, &args); + va_end(args); } TEST(node, opt) { - TraceNode &node = PoolManager::getInstance().Take(); + TraceNode &node = PoolManager::getInstance().Take(); - test_opt(node, "TraceMinTimeMs:23", "TraceOnlyException", nullptr); + test_opt(node, "TraceMinTimeMs:23", "TraceOnlyException", nullptr); - node.cumulative_time = 22; - EXPECT_FALSE(node.checkOpt()); - node.cumulative_time = 23; - EXPECT_TRUE(node.checkOpt()); + node.cumulative_time = 22; + EXPECT_FALSE(node.checkOpt()); + node.cumulative_time = 23; + EXPECT_TRUE(node.checkOpt()); - node.cumulative_time = 0; - node.mHasExp = true; - EXPECT_TRUE(node.checkOpt()); - node.mHasExp = false; - EXPECT_FALSE(node.checkOpt()); + node.cumulative_time = 0; + node.mHasExp = true; + EXPECT_TRUE(node.checkOpt()); + node.mHasExp = false; + EXPECT_FALSE(node.checkOpt()); - PoolManager::getInstance().Restore(node); - // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); + PoolManager::getInstance().Restore(node); + // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); } static std::string span; -void capture(const char *msg) -{ - span = msg; -} +void capture(const char *msg) { span = msg; } //./bin/TestCommon --gtest_filter=node.pinpoint_start_traceV1 TEST(node, pinpoint_start_traceV1) { - auto count = usedNode(); - register_span_handler(capture); - NodeID root, child1; - root = pinpoint_start_trace(E_ROOT_NODE); - child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "Take1sec", E_LOC_CURRENT); - sleep(1); - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); - pinpoint_add_clue(child1, "name", "Exception", E_LOC_CURRENT); - pinpoint_add_exception(child1, "xxxxxxxxx"); - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:2000", nullptr); - pinpoint_add_clue(child1, "name", "TraceMinTimeMs:2000", E_LOC_CURRENT); - sleep(1); - - { - NodeID child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-1", E_LOC_CURRENT); - pinpoint_end_trace(child); - child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-2", E_LOC_CURRENT); - pinpoint_end_trace(child); - child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-3", E_LOC_CURRENT); - pinpoint_end_trace(child); - } - - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); - pinpoint_add_clue(child1, "name", "NoException", E_LOC_CURRENT); - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:-23", nullptr); - pinpoint_add_clue(child1, "name", "TraceMinTimeMs:-23", E_LOC_CURRENT); - pinpoint_end_trace(child1); - - pinpoint_end_trace(root); - std::cout << span << std::endl; - EXPECT_TRUE(span.find("Take1sec") != span.npos); - EXPECT_TRUE(span.find("Exception") != span.npos); - EXPECT_TRUE(span.find("TraceMinTimeMs:2000") == span.npos); - EXPECT_TRUE(span.find("NoException") == span.npos); - - EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-3") == span.npos); - EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-2") == span.npos); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + register_span_handler(capture); + NodeID root, child1; + root = pinpoint_start_trace(E_ROOT_NODE); + child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "Take1sec", E_LOC_CURRENT); + sleep(1); + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); + pinpoint_add_clue(child1, "name", "Exception", E_LOC_CURRENT); + pinpoint_add_exception(child1, "xxxxxxxxx"); + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:2000", nullptr); + pinpoint_add_clue(child1, "name", "TraceMinTimeMs:2000", E_LOC_CURRENT); + sleep(1); + + { + NodeID child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-1", E_LOC_CURRENT); + pinpoint_end_trace(child); + child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-2", E_LOC_CURRENT); + pinpoint_end_trace(child); + child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-3", E_LOC_CURRENT); + pinpoint_end_trace(child); + } + + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); + pinpoint_add_clue(child1, "name", "NoException", E_LOC_CURRENT); + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:-23", nullptr); + pinpoint_add_clue(child1, "name", "TraceMinTimeMs:-23", E_LOC_CURRENT); + pinpoint_end_trace(child1); + + pinpoint_end_trace(root); + std::cout << span << std::endl; + EXPECT_TRUE(span.find("Take1sec") != span.npos); + EXPECT_TRUE(span.find("Exception") != span.npos); + EXPECT_TRUE(span.find("TraceMinTimeMs:2000") == span.npos); + EXPECT_TRUE(span.find("NoException") == span.npos); + + EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-3") == span.npos); + EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-2") == span.npos); + EXPECT_EQ(count, usedNode()); } TEST(node, leak_node) { - auto count = PoolManager::getInstance().freeNodesCount(); - NodeID root, child1, child2; - root = pinpoint_start_trace(E_ROOT_NODE); - child1 = pinpoint_start_trace(root); - child2 = pinpoint_start_trace(child1); - // root goes first - pinpoint_end_trace(root); - - pinpoint_end_trace(child1); - pinpoint_end_trace(child2); - - EXPECT_EQ(count, PoolManager::getInstance().freeNodesCount()); - show_status(); + auto count = PoolManager::getInstance().freeNodesCount(); + NodeID root, child1, child2; + root = pinpoint_start_trace(E_ROOT_NODE); + child1 = pinpoint_start_trace(root); + child2 = pinpoint_start_trace(child1); + // root goes first + pinpoint_end_trace(root); + + pinpoint_end_trace(child1); + pinpoint_end_trace(child2); + + EXPECT_EQ(count, PoolManager::getInstance().freeNodesCount()); + show_status(); } TEST(node, tons_of_nodes_01) { - auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - for (int i = 0; i < 1000; i++) - { - NodeID child1 = pinpoint_start_trace(root); - pinpoint_end_trace(child1); - } - pinpoint_end_trace(root); - - EXPECT_EQ(count, usedNode()); //); - - count = usedNode(); - root = pinpoint_start_trace(E_ROOT_NODE); - NodeID child1 = root; - for (int i = 0; i < 1000; i++) - { - NodeID child = pinpoint_start_trace(child1); - mark_current_trace_status(root, E_OFFLINE); - pinpoint_end_trace(child); - child1 = child; - } - mark_current_trace_status(root, E_TRACE_BLOCK); - pinpoint_end_trace(root); - - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + for (int i = 0; i < 1000; i++) { + NodeID child1 = pinpoint_start_trace(root); + pinpoint_end_trace(child1); + } + pinpoint_end_trace(root); + + EXPECT_EQ(count, usedNode()); //); + + count = usedNode(); + root = pinpoint_start_trace(E_ROOT_NODE); + NodeID child1 = root; + for (int i = 0; i < 1000; i++) { + NodeID child = pinpoint_start_trace(child1); + mark_current_trace_status(root, E_OFFLINE); + pinpoint_end_trace(child); + child1 = child; + } + mark_current_trace_status(root, E_TRACE_BLOCK); + pinpoint_end_trace(root); + + EXPECT_EQ(count, usedNode()); } TEST(node, tons_of_nodes_2k) { - auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - NodeID next = root; - for (int i = 0; i < 2000; i++) - { - NodeID child = pinpoint_start_trace(next); - pinpoint_end_trace(child); - if (i % 2 == 0) - { - next = child; - } - } - pinpoint_end_trace(root); - - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + NodeID next = root; + for (int i = 0; i < 2000; i++) { + NodeID child = pinpoint_start_trace(next); + pinpoint_end_trace(child); + if (i % 2 == 0) { next = child; } + } + pinpoint_end_trace(root); + + EXPECT_EQ(count, usedNode()); } TEST(node, tons_of_nodes_leak) { - auto count = usedNode(); + auto count = usedNode(); - NodeID root, child_1, child_2; - root = pinpoint_start_trace(E_ROOT_NODE); + NodeID root, child_1, child_2; + root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - child_2 = pinpoint_start_trace(child_1); + child_1 = pinpoint_start_trace(root); + child_2 = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_2); + pinpoint_end_trace(child_2); - pinpoint_end_trace(root); - pinpoint_end_trace(child_1); - EXPECT_EQ(count, usedNode()); + pinpoint_end_trace(root); + pinpoint_end_trace(child_1); + EXPECT_EQ(count, usedNode()); } TEST(node, tons_of_nodes_free_all) { - auto count = usedNode(); + auto count = usedNode(); - NodeID root, child_1, child_2; - root = pinpoint_start_trace(E_ROOT_NODE); + NodeID root, child_1, child_2; + root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - child_2 = pinpoint_start_trace(child_1); - freeNodeTree(root); - pinpoint_end_trace(child_2); + child_1 = pinpoint_start_trace(root); + child_2 = pinpoint_start_trace(child_1); + freeNodeTree(root); + pinpoint_end_trace(child_2); - pinpoint_end_trace(root); - pinpoint_end_trace(child_1); - EXPECT_EQ(count, usedNode()); + pinpoint_end_trace(root); + pinpoint_end_trace(child_1); + EXPECT_EQ(count, usedNode()); } //./bin/TestCommon --gtest_filter=node.free_when_add TEST(node, free_when_add) { - auto count = usedNode(); - NodeID root; - auto make_it_busy = [&]() - { - auto w_root = PoolManager::getInstance().GetWrapperNode(); - root = w_root->mPoolIndex; - auto w_child = PoolManager::getInstance().GetWrapperNode(); - w_root->addChild(w_child); - w_child->AddTraceDetail("E_ROOT_NODE", 234); - std::this_thread::sleep_for(std::chrono::seconds(2)); - }; - std::thread t(make_it_busy); - std::this_thread::sleep_for(std::chrono::seconds(1)); - auto start = Helper::get_current_msec_stamp(); - freeNodeTree(root); - freeNodeTree(E_INVALID_NODE); - freeNodeTree(E_ROOT_NODE); - auto end = Helper::get_current_msec_stamp() - start; - printf("it takes: %ld to free ", end); - t.join(); - EXPECT_EQ(count, usedNode()); - EXPECT_TRUE(end >= 100); + auto count = usedNode(); + NodeID root; + auto make_it_busy = [&]() { + auto w_root = PoolManager::getInstance().GetWrapperNode(); + root = w_root->mPoolIndex; + auto w_child = PoolManager::getInstance().GetWrapperNode(); + w_root->addChild(w_child); + w_child->AddTraceDetail("E_ROOT_NODE", 234); + std::this_thread::sleep_for(std::chrono::seconds(2)); + }; + std::thread t(make_it_busy); + std::this_thread::sleep_for(std::chrono::seconds(1)); + auto start = Helper::get_current_msec_stamp(); + freeNodeTree(root); + freeNodeTree(E_INVALID_NODE); + freeNodeTree(E_ROOT_NODE); + auto end = Helper::get_current_msec_stamp() - start; + printf("it takes: %ld to free ", end); + t.join(); + EXPECT_EQ(count, usedNode()); + EXPECT_TRUE(end >= 100); } //./bin/TestCommon --gtest_filter=node.orphan_node TEST(node, orphan_node) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_1); - pinpoint_end_trace(root); - - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(E_ROOT_NODE); - debug_nodeid(orphan); - pinpoint_end_trace(orphan); - debug_nodeid(orphan); - pinpoint_end_trace(child_1); - pinpoint_end_trace(root); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + orphan = pinpoint_start_trace(child_1); + pinpoint_end_trace(child_1); + pinpoint_end_trace(root); + + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(E_ROOT_NODE); + debug_nodeid(orphan); + pinpoint_end_trace(orphan); + debug_nodeid(orphan); + pinpoint_end_trace(child_1); + pinpoint_end_trace(root); + EXPECT_EQ(count, usedNode()); } //./bin/TestCommon --gtest_filter=node.orphan_node_01 TEST(node, orphan_node_01) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - pinpoint_end_trace(root); - orphan = pinpoint_start_trace(child_1); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + pinpoint_end_trace(root); + orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_1); - pinpoint_end_trace(orphan); + pinpoint_end_trace(child_1); + pinpoint_end_trace(orphan); - EXPECT_EQ(count, usedNode()); + EXPECT_EQ(count, usedNode()); } //./bin/TestCommon --gtest_filter=node.orphan_root_parent_end TEST(node, orphan_parent_root_end) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_1); - pinpoint_end_trace(root); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + orphan = pinpoint_start_trace(child_1); + pinpoint_end_trace(child_1); + pinpoint_end_trace(root); - pinpoint_end_trace(orphan); + pinpoint_end_trace(orphan); - EXPECT_EQ(count, usedNode()); + EXPECT_EQ(count, usedNode()); } TEST(node, orphan_root_parent_end) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(root); - pinpoint_end_trace(child_1); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + orphan = pinpoint_start_trace(child_1); + pinpoint_end_trace(root); + pinpoint_end_trace(child_1); - pinpoint_end_trace(orphan); + pinpoint_end_trace(orphan); - EXPECT_EQ(count, usedNode()); + EXPECT_EQ(count, usedNode()); } // ./bin/TestCommon --gtest_filter=node.end_trace_in_mt TEST(node, end_trace_in_mt) { - auto count = usedNode(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - NodeID next = root; - // limit size 100; due to https://github.com/pinpoint-apm/pinpoint-c-agent/runs/6806024797?check_suite_focus=true bus error under macos - for (int i = 0; i < 100; i++) - { - next = pinpoint_start_trace(next); - pinpoint_end_trace(next); - } - - std::mutex mtx; - std::condition_variable cv; - - auto thread_func = [&]() - { - std::unique_lock lck(mtx); - cv.wait(lck); - pp_trace("%lu ", std::this_thread::get_id()); - pinpoint_end_trace(root); - }; - std::vector threads; - for (int i = 0; i < 10; i++) - { - // std::thread t(thread_func); - threads.emplace_back(thread_func); - } - // wait for all threads running - sleep(2); - cv.notify_all(); - for (auto &thread : threads) - thread.join(); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + NodeID next = root; + // limit size 100; due to https://github.com/pinpoint-apm/pinpoint-c-agent/runs/6806024797?check_suite_focus=true bus error under macos + for (int i = 0; i < 100; i++) { + next = pinpoint_start_trace(next); + pinpoint_end_trace(next); + } + + std::mutex mtx; + std::condition_variable cv; + + auto thread_func = [&]() { + std::unique_lock lck(mtx); + cv.wait(lck); + pp_trace("%lu ", std::this_thread::get_id()); + pinpoint_end_trace(root); + }; + std::vector threads; + for (int i = 0; i < 10; i++) { + // std::thread t(thread_func); + threads.emplace_back(thread_func); + } + // wait for all threads running + sleep(2); + cv.notify_all(); + for (auto &thread : threads) thread.join(); + EXPECT_EQ(count, usedNode()); } // ./bin/TestCommon --gtest_filter=node.max_sub_nodes TEST(node, max_sub_nodes) { - auto count = usedNode(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - while (true) - { - NodeID next = pinpoint_start_trace(root); - if (next == E_INVALID_NODE) - { - break; - } - pinpoint_end_trace(next); - } - pinpoint_end_trace(root); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + while (true) { + NodeID next = pinpoint_start_trace(root); + if (next == E_INVALID_NODE) { break; } + pinpoint_end_trace(next); + } + pinpoint_end_trace(root); + EXPECT_EQ(count, usedNode()); } \ No newline at end of file diff --git a/common/test/test_node_pool.cc b/common/test/test_node_pool.cc index c248cf0ce..8229eef46 100644 --- a/common/test/test_node_pool.cc +++ b/common/test/test_node_pool.cc @@ -8,57 +8,55 @@ using NodePool::TraceNode; TEST(poolManger, get_and_give_back) { - NodePool::PoolManager pool; - // new - TraceNode &_node = pool.Take(); - void *p = &_node; - NodeID id = _node.getId(); - NodeID child, next; - // give back - pool.Restore(id, child, next); - EXPECT_EQ(child, E_INVALID_NODE); - EXPECT_EQ(next, E_INVALID_NODE); - TraceNode &_node_01 = pool.Take(); + NodePool::PoolManager pool; + // new + TraceNode &_node = pool.Take(); + void *p = &_node; + NodeID id = _node.getId(); + NodeID child, next; + // give back + pool.Restore(id, child, next); + EXPECT_EQ(child, E_INVALID_NODE); + EXPECT_EQ(next, E_INVALID_NODE); + TraceNode &_node_01 = pool.Take(); - // ref current - TraceNode &ref_new_node = pool.Take(_node_01.getId()); + // ref current + TraceNode &ref_new_node = pool.Take(_node_01.getId()); - EXPECT_EQ(p, &_node); - EXPECT_EQ(ref_new_node, _node); - // reuse the same id - EXPECT_EQ(id, _node.getId()); - EXPECT_THROW(pool.Take(NodeID(100)), std::out_of_range); - EXPECT_THROW(pool.Take(NodeID(10000)), std::out_of_range); + EXPECT_EQ(p, &_node); + EXPECT_EQ(ref_new_node, _node); + // reuse the same id + EXPECT_EQ(id, _node.getId()); + EXPECT_THROW(pool.Take(NodeID(100)), std::out_of_range); + EXPECT_THROW(pool.Take(NodeID(10000)), std::out_of_range); } static NodePool::PoolManager g_pool; void test_node_pool(bool &result) { - NodeID it = E_INVALID_NODE; - for (int i = 0; i < 1000; i++) - { - TraceNode &_node = g_pool.Take(); - usleep(1000); - if (_node.getId() == it) - { - result = false; - return; - } - g_pool.Restore(_node); - // g_pool.freeNode(_node.getId()); + NodeID it = E_INVALID_NODE; + for (int i = 0; i < 1000; i++) { + TraceNode &_node = g_pool.Take(); + usleep(1000); + if (_node.getId() == it) { + result = false; + return; } - result = true; + g_pool.Restore(_node); + // g_pool.freeNode(_node.getId()); + } + result = true; } TEST(poolManger, get_and_give_back_tls) { - bool rth1, rth2; - std::thread t1(test_node_pool, std::ref(rth1)); - std::thread t2(test_node_pool, std::ref(rth2)); + bool rth1, rth2; + std::thread t1(test_node_pool, std::ref(rth1)); + std::thread t2(test_node_pool, std::ref(rth2)); - t1.join(); - t2.join(); - EXPECT_TRUE(rth1); - EXPECT_TRUE(rth2); + t1.join(); + t2.join(); + EXPECT_TRUE(rth1); + EXPECT_TRUE(rth2); } diff --git a/common/test/test_trans_layer.cc b/common/test/test_trans_layer.cc index 6bb088f29..60da29cc9 100644 --- a/common/test/test_trans_layer.cc +++ b/common/test/test_trans_layer.cc @@ -21,123 +21,118 @@ bool run = true; void sig_exit(int signm) { - (void)signm; - run = false; + (void) signm; + run = false; } int fack_server() { - int fd = socket(AF_UNIX, SOCK_STREAM, 0); - struct sockaddr_un address = {0, {0}}; - address.sun_family = AF_UNIX; - strncpy(address.sun_path, unix_socket, sizeof(address.sun_path) - 1); - remove(unix_socket); - if (bind(fd, (struct sockaddr *)&address, sizeof(address)) == -1) - { - pp_trace("bind server socket failed:%s", strerror(errno)); - return 0; - } - listen(fd, 10); - char buffer[1024] = {0}; - struct sockaddr addr; - socklen_t addrlen; - int cfd = accept(fd, &addr, &addrlen); - assert(cfd != -1); - pp_trace("recv cfd:%d", cfd); - Json::Value agentInfo; - - agentInfo["time"] = 1234567; - agentInfo["id"] = "test-app"; - agentInfo["name"] = "test-name"; - - Json::FastWriter writer; - std::string msg = writer.write(agentInfo); - strcpy((char *)buffer + sizeof(Header), msg.c_str()); - - int len = msg.length(); - Header *header = (Header *)buffer; - header->type = htonl(RESPONSE_AGENT_INFO); - header->length = htonl(len); - int ret = send(cfd, buffer, len + sizeof(*header), 0); - pp_trace("send[%d] [%d] %s ", cfd, ret, strerror(errno)); - recv(cfd, buffer, 1024, 0); - close(cfd); + int fd = socket(AF_UNIX, SOCK_STREAM, 0); + struct sockaddr_un address = {0, {0}}; + address.sun_family = AF_UNIX; + strncpy(address.sun_path, unix_socket, sizeof(address.sun_path) - 1); + remove(unix_socket); + if (bind(fd, (struct sockaddr *) &address, sizeof(address)) == -1) { + pp_trace("bind server socket failed:%s", strerror(errno)); return 0; + } + listen(fd, 10); + char buffer[1024] = {0}; + struct sockaddr addr; + socklen_t addrlen; + int cfd = accept(fd, &addr, &addrlen); + assert(cfd != -1); + pp_trace("recv cfd:%d", cfd); + Json::Value agentInfo; + + agentInfo["time"] = 1234567; + agentInfo["id"] = "test-app"; + agentInfo["name"] = "test-name"; + + Json::FastWriter writer; + std::string msg = writer.write(agentInfo); + strcpy((char *) buffer + sizeof(Header), msg.c_str()); + + int len = msg.length(); + Header *header = (Header *) buffer; + header->type = htonl(RESPONSE_AGENT_INFO); + header->length = htonl(len); + int ret = send(cfd, buffer, len + sizeof(*header), 0); + pp_trace("send[%d] [%d] %s ", cfd, ret, strerror(errno)); + recv(cfd, buffer, 1024, 0); + close(cfd); + return 0; } void handle_agent_info(int type, const char *buf, size_t len) { - printf("%s", buf); - EXPECT_EQ(type, RESPONSE_AGENT_INFO); - Json::Value root; - Json::Reader reader; - reader.parse(buf, buf + len, root); - EXPECT_EQ(root["time"].asInt64(), 1234567); - EXPECT_STREQ(root["id"].asCString(), "test-app"); - EXPECT_STREQ(root["name"].asCString(), "test-name"); - run = false; + printf("%s", buf); + EXPECT_EQ(type, RESPONSE_AGENT_INFO); + Json::Value root; + Json::Reader reader; + reader.parse(buf, buf + len, root); + EXPECT_EQ(root["time"].asInt64(), 1234567); + EXPECT_STREQ(root["id"].asCString(), "test-app"); + EXPECT_STREQ(root["name"].asCString(), "test-name"); + run = false; } TEST(translayer, unix_socket_layer) { - pid_t pid = fork(); - if (pid == 0) - { - fack_server(); - exit(0); - } - sleep(3); - std::string remote = global_agent_info.co_host; - TransLayer layer(remote); - using namespace std::placeholders; - layer.registerPeerMsgCallback(std::bind(handle_agent_info, _1, _2, _3), NULL); - while (run) - { - layer.trans_layer_pool(300); - } - std::string data = "msg-1918"; - layer.copy_into_send_buffer(data); - layer.forceFlushMsg(10); - waitpid(pid, 0, 0); + pid_t pid = fork(); + if (pid == 0) { + fack_server(); + exit(0); + } + sleep(3); + std::string remote = global_agent_info.co_host; + TransLayer layer(remote); + using namespace std::placeholders; + layer.registerPeerMsgCallback(std::bind(handle_agent_info, _1, _2, _3), NULL); + while (run) { layer.trans_layer_pool(300); } + std::string data = "msg-1918"; + layer.copy_into_send_buffer(data); + layer.forceFlushMsg(10); + waitpid(pid, 0, 0); } TEST(translayer, stream_socket_layer) { - int fd = -1; - fd = TransLayer::connect_stream_remote("www.naver.com:80"); - EXPECT_GT(fd, 2); - close(fd); + int fd = -1; + fd = TransLayer::connect_stream_remote("www.naver.com:80"); + EXPECT_GT(fd, 2); + close(fd); - fd = TransLayer::connect_stream_remote("172.217.175.68:80"); - EXPECT_GT(fd, 2); - close(fd); + fd = TransLayer::connect_stream_remote("172.217.175.68:80"); + EXPECT_GT(fd, 2); + close(fd); - fd = TransLayer::connect_stream_remote("-.217.175.68:80"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote("-.217.175.68:80"); + EXPECT_EQ(fd, -1); - fd = TransLayer::connect_stream_remote("-.217.175.68:-80"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote("-.217.175.68:-80"); + EXPECT_EQ(fd, -1); - fd = TransLayer::connect_stream_remote("-.217.175.68"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote("-.217.175.68"); + EXPECT_EQ(fd, -1); - fd = TransLayer::connect_stream_remote(":90"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote(":90"); + EXPECT_EQ(fd, -1); } TEST(ConnectionPool, API) { - std::string remote = global_agent_info.co_host; - SpanConnectionPool _pool(remote.c_str()); + std::string remote = global_agent_info.co_host; + SpanConnectionPool _pool(remote.c_str()); - // SpanConnectionPool _pool1 = _pool; - // (void)_pool1; + // SpanConnectionPool _pool1 = _pool; + // (void)_pool1; - TransConnection _conn = _pool.get(); + TransConnection _conn = _pool.get(); - EXPECT_EQ(_conn->connect_stream_remote("-.217.175.68:-80"), -1); + EXPECT_EQ(_conn->connect_stream_remote("-.217.175.68:-80"), -1); - _pool.free(_conn); + _pool.free(_conn); } #pragma GCC diagnostic pop \ No newline at end of file diff --git a/common/test/test_util.cc b/common/test/test_util.cc index a2f0176c7..a1d6767f1 100644 --- a/common/test/test_util.cc +++ b/common/test/test_util.cc @@ -35,136 +35,129 @@ using NodePool::PoolManager; using NodePool::TraceNode; TEST(util, sst) { - ADDTRACE(); + ADDTRACE(); - std::this_thread::sleep_for(seconds(1)); + std::this_thread::sleep_for(seconds(1)); } TEST(util, onOFFline) { - SafeSharedState &_state = SafeSharedState::instance(); - EXPECT_FALSE(_state.isReady()); - _state.updateStartTime(1316615272); - // EXPECT_EQ(1316615272, _state.getStartTime()); - EXPECT_TRUE(_state.isReady()); + SafeSharedState &_state = SafeSharedState::instance(); + EXPECT_FALSE(_state.isReady()); + _state.updateStartTime(1316615272); + // EXPECT_EQ(1316615272, _state.getStartTime()); + EXPECT_TRUE(_state.isReady()); } TEST(util, time_in_msec) { - uint64_t time = Helper::get_current_msec_stamp(); - std::this_thread::sleep_for(seconds(1)); - EXPECT_GE(Helper::get_current_msec_stamp(), time + 1000); + uint64_t time = Helper::get_current_msec_stamp(); + std::this_thread::sleep_for(seconds(1)); + EXPECT_GE(Helper::get_current_msec_stamp(), time + 1000); } // restrict typeva_start TEST(util, test_node_to_string) { - Json::Value _value; + Json::Value _value; - _value["a"] = 1; - _value["b"] = 1; - _value["d"] = 1; + _value["a"] = 1; + _value["b"] = 1; + _value["d"] = 1; - std::string str = Helper::node_tree_to_string(_value); - EXPECT_STREQ(str.c_str(), "{\"a\":1,\"b\":1,\"d\":1}"); + std::string str = Helper::node_tree_to_string(_value); + EXPECT_STREQ(str.c_str(), "{\"a\":1,\"b\":1,\"d\":1}"); } int sum(int n_args, ...) { - va_list ap; - va_start(ap, n_args); - int var = n_args; + va_list ap; + va_start(ap, n_args); + int var = n_args; - int total = n_args; - do - { - var = va_arg(ap, int); - total += var; - } while (var != 0); + int total = n_args; + do { + var = va_arg(ap, int); + total += var; + } while (var != 0); - va_end(ap); + va_end(ap); - return total; + return total; } //./bin/unittest --gtest_filter=util.variadic_func TEST(util, variadic_func_int) { - EXPECT_EQ(sum(1, 2, 3, 4, 5, 6, 0), 21); - EXPECT_EQ(sum(1, 2, 3, 5, 0), 11); + EXPECT_EQ(sum(1, 2, 3, 4, 5, 6, 0), 21); + EXPECT_EQ(sum(1, 2, 3, 5, 0), 11); } int opt(const char *start, ...) { - va_list ap; - va_start(ap, start); - const char *var = start; + va_list ap; + va_start(ap, start); + const char *var = start; - int total = 0; - while (var != nullptr) - { - printf("%s\n", var); - total++; - var = va_arg(ap, const char *); - } + int total = 0; + while (var != nullptr) { + printf("%s\n", var); + total++; + var = va_arg(ap, const char *); + } - va_end(ap); + va_end(ap); - return total; + return total; } //./bin/unittest --gtest_filter=util.variadic_func_str TEST(util, variadic_func_str) { - EXPECT_EQ(opt("a", "b", "c", "d", nullptr), 4); - EXPECT_EQ(opt("a", "b", "c", nullptr), 3); + EXPECT_EQ(opt("a", "b", "c", "d", nullptr), 4); + EXPECT_EQ(opt("a", "b", "c", nullptr), 3); } TEST(util, mergeTraceNodeTree) { - TraceNode &n1 = PoolManager::getInstance().Take(); - TraceNode &n2 = PoolManager::getInstance().Take(); - TraceNode &n3 = PoolManager::getInstance().Take(); - TraceNode &n4 = PoolManager::getInstance().Take(); - - n2.mParentId = n1.mPoolIndex; - n1.mChildHeadId = n2.mPoolIndex; - n3.mParentId = n2.mPoolIndex; - n4.mParentId = n2.mPoolIndex; - n3.mNextId = n4.mPoolIndex; - n2.mChildHeadId = n3.mPoolIndex; - - Json::Value var = Helper::mergeTraceNodeTree(n1); - std::cout << var.toStyledString(); + TraceNode &n1 = PoolManager::getInstance().Take(); + TraceNode &n2 = PoolManager::getInstance().Take(); + TraceNode &n3 = PoolManager::getInstance().Take(); + TraceNode &n4 = PoolManager::getInstance().Take(); + + n2.mParentId = n1.mPoolIndex; + n1.mChildHeadId = n2.mPoolIndex; + n3.mParentId = n2.mPoolIndex; + n4.mParentId = n2.mPoolIndex; + n3.mNextId = n4.mPoolIndex; + n2.mChildHeadId = n3.mPoolIndex; + + Json::Value var = Helper::mergeTraceNodeTree(n1); + std::cout << var.toStyledString(); } std::string span; -void captureSpan(const char *s) -{ - span = s; -} +void captureSpan(const char *s) { span = s; } TEST(util, mergeTraceNodeTree_1) { - - register_span_handler(captureSpan); - - NodeID id1, - id2, id3, id4; - Json::Value var; - id1 = pinpoint_start_trace(E_ROOT_NODE); - pinpoint_add_clue(id1, "name", "id1", E_LOC_CURRENT); - id2 = pinpoint_start_trace(id1); - pinpoint_add_clue(id2, "name", "id2", E_LOC_CURRENT); - id3 = pinpoint_start_trace(id2); - pinpoint_add_clue(id3, "name", "id3", E_LOC_CURRENT); - id4 = pinpoint_start_trace(id2); - pinpoint_add_clue(id4, "name", "id4", E_LOC_CURRENT); - pinpoint_end_trace(id3); - pinpoint_end_trace(id2); - pinpoint_end_trace(id1); - pinpoint_end_trace(id4); - EXPECT_TRUE(span.find("id4") != span.npos); - EXPECT_TRUE(span.find("id1") != span.npos); - EXPECT_TRUE(span.find("id2") != span.npos); - EXPECT_TRUE(span.find("id3") != span.npos); - EXPECT_TRUE(span.find("calls") != span.npos); + register_span_handler(captureSpan); + + NodeID id1, id2, id3, id4; + Json::Value var; + id1 = pinpoint_start_trace(E_ROOT_NODE); + pinpoint_add_clue(id1, "name", "id1", E_LOC_CURRENT); + id2 = pinpoint_start_trace(id1); + pinpoint_add_clue(id2, "name", "id2", E_LOC_CURRENT); + id3 = pinpoint_start_trace(id2); + pinpoint_add_clue(id3, "name", "id3", E_LOC_CURRENT); + id4 = pinpoint_start_trace(id2); + pinpoint_add_clue(id4, "name", "id4", E_LOC_CURRENT); + pinpoint_end_trace(id3); + pinpoint_end_trace(id2); + pinpoint_end_trace(id1); + pinpoint_end_trace(id4); + EXPECT_TRUE(span.find("id4") != span.npos); + EXPECT_TRUE(span.find("id1") != span.npos); + EXPECT_TRUE(span.find("id2") != span.npos); + EXPECT_TRUE(span.find("id3") != span.npos); + EXPECT_TRUE(span.find("calls") != span.npos); } diff --git a/src/PHP/pinpoint_php.cpp b/src/PHP/pinpoint_php.cpp index c3ea49aba..d4fe9dda3 100644 --- a/src/PHP/pinpoint_php.cpp +++ b/src/PHP/pinpoint_php.cpp @@ -39,11 +39,11 @@ #include "php.h" #include "php_ini.h" -//#include "php_var.h" +// #include "php_var.h" #include "ext/standard/info.h" -#include "php_pinpoint_php.h" #include "common.h" +#include "php_pinpoint_php.h" #include #ifdef COMPILE_DL_PINPOINT_PHP @@ -79,20 +79,16 @@ static void pinpoint_log(char *msg); PHP_INI_BEGIN() -STD_PHP_INI_ENTRY("pinpoint_php.SendSpanTimeOutMs", "0", PHP_INI_ALL, - OnUpdateLong, w_timeout_ms, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.SendSpanTimeOutMs", "0", PHP_INI_ALL, OnUpdateLong, w_timeout_ms, zend_pinpoint_php_globals, pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.CollectorHost", "unix:/tmp/collector.sock", PHP_INI_ALL, - OnUpdateString, co_host, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.CollectorHost", "unix:/tmp/collector.sock", PHP_INI_ALL, OnUpdateString, co_host, zend_pinpoint_php_globals, + pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.UnitTest", "no", PHP_INI_ALL, - OnUpdateBool, utest_flag, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.UnitTest", "no", PHP_INI_ALL, OnUpdateBool, utest_flag, zend_pinpoint_php_globals, pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.TraceLimit", "-1", PHP_INI_ALL, - OnUpdateLong, tracelimit, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.TraceLimit", "-1", PHP_INI_ALL, OnUpdateLong, tracelimit, zend_pinpoint_php_globals, pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.DebugReport", "no", PHP_INI_ALL, - OnUpdateBool, debug_report, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.DebugReport", "no", PHP_INI_ALL, OnUpdateBool, debug_report, zend_pinpoint_php_globals, pinpoint_php_globals) PHP_INI_END() @@ -139,19 +135,13 @@ ZEND_END_ARG_INFO() * Every user visible function must have an entry in pinpioint_php_functions[]. */ const zend_function_entry pinpoint_php_functions[] = { - PHP_FE(pinpoint_start_trace, arginfo_add_id) - PHP_FE(pinpoint_end_trace, arginfo_add_id) - PHP_FE(pinpoint_unique_id, arginfo_none) - PHP_FE(pinpoint_get_func_ref_args, arginfo_none) - PHP_FE(pinpoint_drop_trace, arginfo_add_id) - PHP_FE(pinpoint_start_time, arginfo_none) - PHP_FE(pinpoint_set_context, arginfo_add_id_key_value) - PHP_FE(pinpoint_get_context, arginfo_add_id_value) - PHP_FE(pinpoint_tracelimit, arginfo_add_timestamp) - PHP_FE(pinpoint_mark_as_error, arginfo_add_msg_filename_lineno_id) - PHP_FE(pinpoint_add_clue, arginfo_add_id_key_value_flag) - PHP_FE(pinpoint_add_clues, arginfo_add_id_key_value_flag) - PHP_FE_END /* Must be the last line in pinpioint_php_functions[] */ + PHP_FE(pinpoint_start_trace, arginfo_add_id) PHP_FE(pinpoint_end_trace, arginfo_add_id) PHP_FE(pinpoint_unique_id, arginfo_none) + PHP_FE(pinpoint_get_func_ref_args, arginfo_none) PHP_FE(pinpoint_drop_trace, arginfo_add_id) PHP_FE(pinpoint_start_time, arginfo_none) + PHP_FE(pinpoint_set_context, arginfo_add_id_key_value) PHP_FE(pinpoint_get_context, arginfo_add_id_value) + PHP_FE(pinpoint_tracelimit, arginfo_add_timestamp) PHP_FE(pinpoint_mark_as_error, arginfo_add_msg_filename_lineno_id) + PHP_FE(pinpoint_add_clue, arginfo_add_id_key_value_flag) PHP_FE(pinpoint_add_clues, arginfo_add_id_key_value_flag) + PHP_FE_END /* Must be the last line in + pinpioint_php_functions[] */ }; /* }}} */ @@ -159,19 +149,18 @@ const zend_function_entry pinpoint_php_functions[] = { */ zend_module_entry pinpoint_php_module_entry = { #if ZEND_MODULE_API_NO >= 20010901 - STANDARD_MODULE_HEADER, + STANDARD_MODULE_HEADER, #endif - "pinpoint_php", - pinpoint_php_functions, - PHP_MINIT(pinpoint_php), - PHP_MSHUTDOWN(pinpoint_php), - PHP_RINIT(pinpoint_php), /* Replace with NULL if there's nothing to do at request start */ - PHP_RSHUTDOWN(pinpoint_php), /* Replace with NULL if there's nothing to do at request end */ - PHP_MINFO(pinpoint_php), + "pinpoint_php", pinpoint_php_functions, PHP_MINIT(pinpoint_php), PHP_MSHUTDOWN(pinpoint_php), + PHP_RINIT(pinpoint_php), /* Replace with NULL if there's nothing to do at + request start */ + PHP_RSHUTDOWN(pinpoint_php), /* Replace with NULL if there's nothing to do + at request end */ + PHP_MINFO(pinpoint_php), #if ZEND_MODULE_API_NO >= 20010901 - PHP_PINPOINT_PHP_VERSION, + PHP_PINPOINT_PHP_VERSION, #endif - STANDARD_MODULE_PROPERTIES}; + STANDARD_MODULE_PROPERTIES}; /* }}} */ #if PHP_VERSION_ID >= 80100 void (*old_error_cb)(int type, zend_string *error_filename, const uint32_t error_lineno, zend_string *message); @@ -182,332 +171,291 @@ void (*old_error_cb)(int type, const char *error_filename, const uint error_line #endif #define safe_free(x) \ - if ((x)) \ - { \ - free((x)); \ - (x) = NULL; \ - } + if ((x)) { \ + free((x)); \ + (x) = NULL; \ + } PHP_FUNCTION(pinpoint_drop_trace) { - long _id = -1; - NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; + long _id = -1; + NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); #endif - if (_id == -1) - { - id = pinpoint_get_per_thread_id(); - } - else - { - id = (NodeID)_id; - } - mark_current_trace_status(id, E_TRACE_BLOCK); - RETURN_TRUE; + if (_id == -1) { + id = pinpoint_get_per_thread_id(); + } else { + id = (NodeID) _id; + } + mark_current_trace_status(id, E_TRACE_BLOCK); + RETURN_TRUE; } PHP_FUNCTION(pinpoint_set_context) { - long _id = -1; - std::string key; - zval *zvalue; + long _id = -1; + std::string key; + zval *zvalue; #if PHP_VERSION_ID < 70000 - char *zkey = NULL; - int zkey_len; + char *zkey = NULL; + int zkey_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &zkey, &zkey_len, &zvalue, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey, zkey_len); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &zkey, &zkey_len, &zvalue, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey, zkey_len); #else - zend_string *zkey; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|l", &zkey, &zvalue, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey->val, zkey->len); + zend_string *zkey; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|l", &zkey, &zvalue, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey->val, zkey->len); #endif - if (_id == -1) - { - _id = pinpoint_get_per_thread_id(); - ; - } - - switch (Z_TYPE_P(zvalue)) - { - // case IS_LONG: - // pinpoint_set_context_long(_id,key.c_str(),Z_LVAL_P(zvalue)); - // break; - case IS_STRING: - { - std::string value(Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue)); - pinpoint_set_context_key((NodeID)_id, key.c_str(), value.c_str()); - } - break; + if (_id == -1) { + _id = pinpoint_get_per_thread_id(); + ; + } + + switch (Z_TYPE_P(zvalue)) { + // case IS_LONG: + // pinpoint_set_context_long(_id,key.c_str(),Z_LVAL_P(zvalue)); + // break; + case IS_STRING: { + std::string value(Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue)); + pinpoint_set_context_key((NodeID) _id, key.c_str(), value.c_str()); + } break; default: - zend_error(E_WARNING, "value only support string"); - return; - } - RETURN_TRUE; + zend_error(E_WARNING, "value only support string"); + return; + } + RETURN_TRUE; } PHP_FUNCTION(pinpoint_get_context) { - long _id = -1; - std::string key; + long _id = -1; + std::string key; #if PHP_VERSION_ID < 70000 - char *zkey = NULL; - int zkey_len; + char *zkey = NULL; + int zkey_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &zkey, &zkey_len, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey, zkey_len); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &zkey, &zkey_len, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey, zkey_len); #else - zend_string *zkey; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &zkey, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey->val, zkey->len); + zend_string *zkey; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &zkey, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey->val, zkey->len); #endif - if (_id == -1) - { - _id = pinpoint_get_per_thread_id(); - } - char value[1024] = {0}; - int len = pinpoint_get_context_key((NodeID)_id, key.c_str(), value, 1024); - if (len > 0) - { + if (_id == -1) { _id = pinpoint_get_per_thread_id(); } + char value[1024] = {0}; + int len = pinpoint_get_context_key((NodeID) _id, key.c_str(), value, 1024); + if (len > 0) { #if PHP_VERSION_ID < 70000 - RETURN_STRINGL(value, len, 1); + RETURN_STRINGL(value, len, 1); #else - RETURN_STRINGL(value, len); + RETURN_STRINGL(value, len); #endif - } - else - { - RETURN_FALSE; - } + } else { + RETURN_FALSE; + } } -PHP_FUNCTION(pinpoint_start_time) -{ - RETURN_LONG(pinpoint_start_time()); -} +PHP_FUNCTION(pinpoint_start_time) { RETURN_LONG(pinpoint_start_time()); } PHP_FUNCTION(pinpoint_start_trace) { - - long _id = -1; - NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; + long _id = -1; + NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); #endif - if (_id == -1) - { - id = pinpoint_get_per_thread_id(); - cur_id = pinpoint_start_trace(id); - pinpoint_update_per_thread_id(cur_id); - RETURN_LONG((long)cur_id); - } - else - { - id = (NodeID)_id; - cur_id = pinpoint_start_trace(id); - RETURN_LONG((long)cur_id); - } + if (_id == -1) { + id = pinpoint_get_per_thread_id(); + cur_id = pinpoint_start_trace(id); + pinpoint_update_per_thread_id(cur_id); + RETURN_LONG((long) cur_id); + } else { + id = (NodeID) _id; + cur_id = pinpoint_start_trace(id); + RETURN_LONG((long) cur_id); + } } #if PHP_VERSION_ID >= 80100 void apm_error_cb(int type, zend_string *_error_filename, const uint32_t error_lineno, zend_string *_message) { - char *error_filename = _error_filename->val; - char *msg = _message->val; + char *error_filename = _error_filename->val; + char *msg = _message->val; #elif PHP_VERSION_ID >= 80000 void apm_error_cb(int type, const char *_error_filename, const uint32_t error_lineno, zend_string *_message) { - char *msg = _message->val; - const char *error_filename = _error_filename; + char *msg = _message->val; + const char *error_filename = _error_filename; #else void apm_error_cb(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) { - char *msg; - va_list args_copy; + char *msg; + va_list args_copy; #if PHP_VERSION_ID < 80000 - TSRMLS_FETCH(); + TSRMLS_FETCH(); #endif - va_copy(args_copy, args); - vspprintf(&msg, 0, format, args_copy); - va_end(args_copy); + va_copy(args_copy, args); + vspprintf(&msg, 0, format, args_copy); + va_end(args_copy); #endif - if (!(EG(error_reporting) & type)) - { - return; - } + if (!(EG(error_reporting) & type)) { return; } - catch_error(pinpoint_get_per_thread_id(), msg, error_filename, error_lineno); + catch_error(pinpoint_get_per_thread_id(), msg, error_filename, error_lineno); - pp_trace("apm_error_cb called"); + pp_trace("apm_error_cb called"); #if PHP_VERSION_ID < 80000 - efree(msg); - /// call origin cb - old_error_cb(type, error_filename, error_lineno, format, args); + efree(msg); + /// call origin cb + old_error_cb(type, error_filename, error_lineno, format, args); #else - old_error_cb(type, _error_filename, error_lineno, _message); + old_error_cb(type, _error_filename, error_lineno, _message); #endif } PHP_FUNCTION(pinpoint_end_trace) { - - long _id = -1; - NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; + long _id = -1; + NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); #endif - if (_id == -1) - { - id = pinpoint_get_per_thread_id(); - cur_id = pinpoint_end_trace(id); - pinpoint_update_per_thread_id(cur_id); - RETURN_LONG((long)cur_id); - } - else - { - id = (NodeID)_id; - cur_id = pinpoint_end_trace(id); - RETURN_LONG((long)cur_id); - } + if (_id == -1) { + id = pinpoint_get_per_thread_id(); + cur_id = pinpoint_end_trace(id); + pinpoint_update_per_thread_id(cur_id); + RETURN_LONG((long) cur_id); + } else { + id = (NodeID) _id; + cur_id = pinpoint_end_trace(id); + RETURN_LONG((long) cur_id); + } } PHP_FUNCTION(pinpoint_add_clue) { - std::string key; - std::string value; - long _id = -1; - long _flag = E_LOC_CURRENT; + std::string key; + std::string value; + long _id = -1; + long _flag = E_LOC_CURRENT; #if PHP_VERSION_ID < 70000 - char *zkey = NULL, *zvalue = NULL; - int zkey_len, value_len; + char *zkey = NULL, *zvalue = NULL; + int zkey_len, value_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); - return; - } - key = std::string(zkey, zkey_len); - value = std::string(zvalue, value_len); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); + return; + } + key = std::string(zkey, zkey_len); + value = std::string(zvalue, value_len); #else - zend_string *zkey; - zend_string *zvalue; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); - return; - } - key = std::string(zkey->val, zkey->len); - value = std::string(zvalue->val, zvalue->len); + zend_string *zkey; + zend_string *zvalue; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); + return; + } + key = std::string(zkey->val, zkey->len); + value = std::string(zvalue->val, zvalue->len); #endif - NodeID Id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID)_id); - pinpoint_add_clue(Id, key.c_str(), value.c_str(), (E_NODE_LOC)_flag); + NodeID Id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID) _id); + pinpoint_add_clue(Id, key.c_str(), value.c_str(), (E_NODE_LOC) _flag); } -PHP_FUNCTION(pinpoint_unique_id) -{ - RETURN_LONG(generate_unique_id()); -} +PHP_FUNCTION(pinpoint_unique_id) { RETURN_LONG(generate_unique_id()); } PHP_FUNCTION(pinpoint_mark_as_error) { - std::string msg; - std::string fileName; - long _lineno = 0; - long _id = -1; + std::string msg; + std::string fileName; + long _lineno = 0; + long _id = -1; #if PHP_VERSION_ID < 70000 - char *zkey = NULL, *zvalue = NULL; - int zkey_len, value_len; - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_lineno, &_id) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); - return; - } - msg = std::string(zkey, zkey_len); - fileName = std::string(zvalue, value_len); + char *zkey = NULL, *zvalue = NULL; + int zkey_len, value_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_lineno, &_id) == FAILURE) { + zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); + return; + } + msg = std::string(zkey, zkey_len); + fileName = std::string(zvalue, value_len); #else - zend_string *zkey; - zend_string *zvalue; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_lineno, &_id) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); - return; - } - msg = std::string(zkey->val, zkey->len); - fileName = std::string(zvalue->val, zvalue->len); + zend_string *zkey; + zend_string *zvalue; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_lineno, &_id) == FAILURE) { + zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); + return; + } + msg = std::string(zkey->val, zkey->len); + fileName = std::string(zvalue->val, zvalue->len); #endif - NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID)_id); - catch_error(id, msg.c_str(), fileName.c_str(), _lineno); + NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID) _id); + catch_error(id, msg.c_str(), fileName.c_str(), _lineno); } PHP_FUNCTION(pinpoint_add_clues) { - std::string key; - std::string value; - long _id = -1; - long _flag = E_LOC_CURRENT; + std::string key; + std::string value; + long _id = -1; + long _flag = E_LOC_CURRENT; #if PHP_VERSION_ID < 70000 - char *zkey = NULL, *zvalue = NULL; - int zkey_len, value_len; - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); - return; - } - key = std::string(zkey, zkey_len); - value = std::string(zvalue, value_len); + char *zkey = NULL, *zvalue = NULL; + int zkey_len, value_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); + return; + } + key = std::string(zkey, zkey_len); + value = std::string(zvalue, value_len); #else - zend_string *zkey; - zend_string *zvalue; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); - return; - } - key = std::string(zkey->val, zkey->len); - value = std::string(zvalue->val, zvalue->len); + zend_string *zkey; + zend_string *zvalue; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); + return; + } + key = std::string(zkey->val, zkey->len); + value = std::string(zvalue->val, zvalue->len); #endif - NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID)_id); - pinpoint_add_clues(id, key.c_str(), value.c_str(), (E_NODE_LOC)_flag); + NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID) _id); + pinpoint_add_clues(id, key.c_str(), value.c_str(), (E_NODE_LOC) _flag); } /** @@ -518,126 +466,109 @@ PHP_FUNCTION(pinpoint_add_clues) PHP_FUNCTION(pinpoint_get_func_ref_args) { #if PHP_VERSION_ID < 70000 - void **p; - int arg_count; - int i; - zend_execute_data *ex = EG(current_execute_data)->prev_execute_data; - - if (!ex || !ex->function_state.arguments) - { - zend_error(E_WARNING, "pinpoint_get_func_ref_args(): Called from the global scope - no function context"); - RETURN_FALSE; - } - - p = ex->function_state.arguments; - arg_count = (int)(zend_uintptr_t)*p; /* this is the amount of arguments passed to func_get_args(); */ - - array_init_size(return_value, arg_count); - for (i = 0; i < arg_count; i++) - { - zval *element, *arg; - - arg = *((zval **)(p - (arg_count - i))); - element = arg; - Z_ADDREF_P(element); - - zend_hash_next_index_insert(return_value->value.ht, &element, sizeof(zval *), NULL); - } + void **p; + int arg_count; + int i; + zend_execute_data *ex = EG(current_execute_data)->prev_execute_data; + + if (!ex || !ex->function_state.arguments) { + zend_error(E_WARNING, + "pinpoint_get_func_ref_args(): Called from the " + "global scope - no function context"); + RETURN_FALSE; + } + + p = ex->function_state.arguments; + arg_count = (int) (zend_uintptr_t) *p; /* this is the amount of arguments passed + to func_get_args(); */ + + array_init_size(return_value, arg_count); + for (i = 0; i < arg_count; i++) { + zval *element, *arg; + + arg = *((zval **) (p - (arg_count - i))); + element = arg; + Z_ADDREF_P(element); + + zend_hash_next_index_insert(return_value->value.ht, &element, sizeof(zval *), NULL); + } #else - zval *p, *q; - uint32_t arg_count, first_extra_arg; - uint32_t i, n; - zend_execute_data *ex = EX(prev_execute_data); - - if (ZEND_CALL_INFO(ex) & ZEND_CALL_CODE) - { - zend_error(E_WARNING, "pinpoint_get_func_ref_args(): Called from the global scope - no function context"); - RETURN_FALSE; - } + zval *p, *q; + uint32_t arg_count, first_extra_arg; + uint32_t i, n; + zend_execute_data *ex = EX(prev_execute_data); + + if (ZEND_CALL_INFO(ex) & ZEND_CALL_CODE) { + zend_error(E_WARNING, + "pinpoint_get_func_ref_args(): Called from the " + "global scope - no function context"); + RETURN_FALSE; + } #if PHP_VERSION_ID > 70033 - if (zend_forbid_dynamic_call("pinpoint_get_func_ref_args()") == FAILURE) - { - RETURN_FALSE; - } + if (zend_forbid_dynamic_call("pinpoint_get_func_ref_args()") == FAILURE) { RETURN_FALSE; } #endif - arg_count = ZEND_CALL_NUM_ARGS(ex); - - array_init_size(return_value, arg_count); - if (arg_count) - { - first_extra_arg = ex->func->op_array.num_args; - zend_hash_real_init(Z_ARRVAL_P(return_value), 1); - ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) - { - i = 0; - n = 0; - p = ZEND_CALL_ARG(ex, 1); - if (arg_count > first_extra_arg) - { - while (i < first_extra_arg) - { - q = p; - if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) - { - // ZVAL_DEREF(q); - if (Z_OPT_REFCOUNTED_P(q)) - { - Z_ADDREF_P(q); - } - n++; - } - ZEND_HASH_FILL_ADD(q); - p++; - i++; - } - p = ZEND_CALL_VAR_NUM(ex, ex->func->op_array.last_var + ex->func->op_array.T); - } - while (i < arg_count) - { - q = p; - if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) - { - // ZVAL_DEREF(q); - if (Z_OPT_REFCOUNTED_P(q)) - { - Z_ADDREF_P(q); - } - n++; - } - ZEND_HASH_FILL_ADD(q); - p++; - i++; - } - } - ZEND_HASH_FILL_END(); - Z_ARRVAL_P(return_value)->nNumOfElements = n; - } + arg_count = ZEND_CALL_NUM_ARGS(ex); + + array_init_size(return_value, arg_count); + if (arg_count) { + first_extra_arg = ex->func->op_array.num_args; + zend_hash_real_init(Z_ARRVAL_P(return_value), 1); + ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) + { + i = 0; + n = 0; + p = ZEND_CALL_ARG(ex, 1); + if (arg_count > first_extra_arg) { + while (i < first_extra_arg) { + q = p; + if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) { + // ZVAL_DEREF(q); + if (Z_OPT_REFCOUNTED_P(q)) { Z_ADDREF_P(q); } + n++; + } + ZEND_HASH_FILL_ADD(q); + p++; + i++; + } + p = ZEND_CALL_VAR_NUM(ex, ex->func->op_array.last_var + ex->func->op_array.T); + } + while (i < arg_count) { + q = p; + if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) { + // ZVAL_DEREF(q); + if (Z_OPT_REFCOUNTED_P(q)) { Z_ADDREF_P(q); } + n++; + } + ZEND_HASH_FILL_ADD(q); + p++; + i++; + } + } + ZEND_HASH_FILL_END(); + Z_ARRVAL_P(return_value)->nNumOfElements = n; + } #endif } PHP_FUNCTION(pinpoint_tracelimit) { - - long timestamp = -1; + long timestamp = -1; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", ×tamp); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", ×tamp); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", ×tamp); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", ×tamp); #endif - timestamp = (timestamp == -1) ? (time(NULL)) : (timestamp); + timestamp = (timestamp == -1) ? (time(NULL)) : (timestamp); - if (check_tracelimit(timestamp) == 1) - { - RETURN_TRUE; - } - else - { - RETURN_FALSE; - } + if (check_tracelimit(timestamp) == 1) { + RETURN_TRUE; + } else { + RETURN_FALSE; + } } /* {{{ php_pinpioint_php_init_globals @@ -646,7 +577,7 @@ PHP_FUNCTION(pinpoint_tracelimit) */ static void php_pinpoint_php_init_globals(zend_pinpoint_php_globals *pinpoint_php_globals) { - memset(pinpoint_php_globals, 0, sizeof(zend_pinpoint_php_globals)); + memset(pinpoint_php_globals, 0, sizeof(zend_pinpoint_php_globals)); } /* }}} */ @@ -656,28 +587,25 @@ static void php_pinpoint_php_init_globals(zend_pinpoint_php_globals *pinpoint_ph PHP_MINIT_FUNCTION(pinpoint_php) { - ZEND_INIT_MODULE_GLOBALS(pinpoint_php, php_pinpoint_php_init_globals, NULL); - REGISTER_INI_ENTRIES(); - - old_error_cb = zend_error_cb; - zend_error_cb = apm_error_cb; - // global_agent_info. - strncpy(global_agent_info.co_host, PPG(co_host), MAX_ADDRESS_SIZE); - global_agent_info.inter_flag = PPG(debug_report); - global_agent_info.timeout_ms = PPG(w_timeout_ms); - global_agent_info.trace_limit = PPG(tracelimit); - global_agent_info.agent_type = 1500; // PHP - - if (PPG(utest_flag) == 1) - { - global_agent_info.inter_flag |= E_UTEST; - } - else - { - register_error_cb(pinpoint_log); - } - - return SUCCESS; + ZEND_INIT_MODULE_GLOBALS(pinpoint_php, php_pinpoint_php_init_globals, NULL); + REGISTER_INI_ENTRIES(); + + old_error_cb = zend_error_cb; + zend_error_cb = apm_error_cb; + // global_agent_info. + strncpy(global_agent_info.co_host, PPG(co_host), MAX_ADDRESS_SIZE); + global_agent_info.inter_flag = PPG(debug_report); + global_agent_info.timeout_ms = PPG(w_timeout_ms); + global_agent_info.trace_limit = PPG(tracelimit); + global_agent_info.agent_type = 1500; // PHP + + if (PPG(utest_flag) == 1) { + global_agent_info.inter_flag |= E_UTEST; + } else { + register_error_cb(pinpoint_log); + } + + return SUCCESS; } /* }}} */ @@ -685,11 +613,11 @@ PHP_MINIT_FUNCTION(pinpoint_php) */ PHP_MSHUTDOWN_FUNCTION(pinpoint_php) { - /* uncomment this line if you have INI entries - UNREGISTER_INI_ENTRIES(); - */ + /* uncomment this line if you have INI entries + UNREGISTER_INI_ENTRIES(); + */ - return SUCCESS; + return SUCCESS; } /* }}} */ @@ -698,12 +626,11 @@ PHP_MSHUTDOWN_FUNCTION(pinpoint_php) */ PHP_RINIT_FUNCTION(pinpoint_php) { - #if defined(COMPILE_DL_PINPIOINT_PHP) && defined(ZTS) - ZEND_TSRMLS_CACHE_UPDATE(); + ZEND_TSRMLS_CACHE_UPDATE(); #endif - return SUCCESS; + return SUCCESS; } /* }}} */ @@ -712,14 +639,13 @@ PHP_RINIT_FUNCTION(pinpoint_php) */ PHP_RSHUTDOWN_FUNCTION(pinpoint_php) { - NodeID _id = pinpoint_get_per_thread_id(); - if (_id != 0) - { - pinpoint_force_end_trace(_id, 300); - pinpoint_update_per_thread_id(E_ROOT_NODE); - } + NodeID _id = pinpoint_get_per_thread_id(); + if (_id != 0) { + pinpoint_force_end_trace(_id, 300); + pinpoint_update_per_thread_id(E_ROOT_NODE); + } - return SUCCESS; + return SUCCESS; } /* }}} */ @@ -727,23 +653,22 @@ PHP_RSHUTDOWN_FUNCTION(pinpoint_php) */ PHP_MINFO_FUNCTION(pinpoint_php) { - php_info_print_table_start(); - php_info_print_table_header(2, "pinpoint_php support", "enabled"); - php_info_print_table_end(); + php_info_print_table_start(); + php_info_print_table_header(2, "pinpoint_php support", "enabled"); + php_info_print_table_end(); - // /* Remove comments if you have entries in php.ini - DISPLAY_INI_ENTRIES(); - // */ + // /* Remove comments if you have entries in php.ini + DISPLAY_INI_ENTRIES(); + // */ } /* }}} */ void pinpoint_log(char *msg) { - #if PHP_VERSION_ID >= 70100 - php_log_err_with_severity(msg, LOG_DEBUG); + php_log_err_with_severity(msg, LOG_DEBUG); #else - TSRMLS_FETCH(); - php_log_err(msg TSRMLS_CC); + TSRMLS_FETCH(); + php_log_err(msg TSRMLS_CC); #endif }