diff --git a/.github/workflows/php.yml b/.github/workflows/php.yml index 28025abbf..aba64c509 100644 --- a/.github/workflows/php.yml +++ b/.github/workflows/php.yml @@ -41,6 +41,7 @@ jobs: 'Instrumentation/MySqli', 'Instrumentation/OpenAIPHP', 'Instrumentation/PDO', + 'Instrumentation/PgSql', # Sort PSRs numerically. 'Instrumentation/Psr3', 'Instrumentation/Psr6', @@ -78,6 +79,8 @@ jobs: php-version: 8.1 - project: 'Instrumentation/PDO' php-version: 8.1 + - project: 'Instrumentation/PgSql' + php-version: 8.1 steps: - uses: actions/checkout@v4 @@ -86,7 +89,7 @@ jobs: with: php-version: ${{ matrix.php-version }} coverage: xdebug - extensions: ast, amqp, grpc, opentelemetry, rdkafka, mysqli + extensions: ast, amqp, grpc, opentelemetry, rdkafka, mysqli, pgsql - name: Validate composer.json and composer.lock run: composer validate @@ -151,6 +154,11 @@ jobs: run: | docker compose up mysql -d --wait + - name: Start PostgreSQL + if: ${{ matrix.project == 'Instrumentation/PgSql' }} + run: | + docker compose up postgres -d --wait + - name: Run PHPUnit working-directory: src/${{ matrix.project }} run: vendor/bin/phpunit diff --git a/composer.json b/composer.json index 56945bd4b..df892b7b9 100644 --- a/composer.json +++ b/composer.json @@ -33,6 +33,7 @@ "OpenTelemetry\\Contrib\\Instrumentation\\MySqli\\": "src/Instrumentation/MySqli/src", "OpenTelemetry\\Contrib\\Instrumentation\\OpenAIPHP\\": "src/Instrumentation/OpenAIPHP/src", "OpenTelemetry\\Contrib\\Instrumentation\\PDO\\": "src/Instrumentation/PDO/src", + "OpenTelemetry\\Contrib\\Instrumentation\\PgSql\\": "src/Instrumentation/PgSql/src", "OpenTelemetry\\Contrib\\Instrumentation\\Psr3\\": "src/Instrumentation/Psr3/src", "OpenTelemetry\\Contrib\\Instrumentation\\Psr6\\": "src/Instrumentation/Psr6/src", "OpenTelemetry\\Contrib\\Instrumentation\\Psr14\\": "src/Instrumentation/Psr14/src", @@ -73,6 +74,7 @@ "src/Instrumentation/MySqli/_register.php", "src/Instrumentation/OpenAIPHP/_register.php", "src/Instrumentation/PDO/_register.php", + "src/Instrumentation/PgSql/_register.php", "src/Instrumentation/Psr3/_register.php", "src/Instrumentation/Psr6/_register.php", "src/Instrumentation/Psr14/_register.php", @@ -146,6 +148,7 @@ "open-telemetry/opentelemetry-auto-mysqli": "self.version", "open-telemetry/opentelemetry-auto-openai-php": "self.version", "open-telemetry/opentelemetry-auto-pdo": "self.version", + "open-telemetry/opentelemetry-auto-pgsql": "self.version", "open-telemetry/opentelemetry-auto-psr3": "self.version", "open-telemetry/opentelemetry-auto-psr6": "self.version", "open-telemetry/opentelemetry-auto-psr14": "self.version", diff --git a/docker-compose.yaml b/docker-compose.yaml index 263e0d1bd..721241816 100644 --- a/docker-compose.yaml +++ b/docker-compose.yaml @@ -18,6 +18,10 @@ services: MONGODB_HOST: ${MONGODB_HOST:-mongodb} MONGODB_PORT: ${MONGODB_PORT:-27017} MYSQL_HOST: ${MYSQL_HOST:-mysql} + PGSQL_HOST: ${PGSQL_HOST:-postgres} + PGSQL_DATABASE: ${PGSQL_DATABASE:-postgres} + PGSQL_USER: ${PGSQL_USER:-postgres} + PGSQL_PASSWD: ${PGSQL_PASSWD:-postgres_password} zipkin: image: openzipkin/zipkin-slim @@ -88,3 +92,16 @@ services: retries: 3 volumes: - ./docker/mysql/init.sql:/docker-entrypoint-initdb.d/init.sql + + postgres: + image: postgres:17 + hostname: postgres + ports: + - "5432:5432/tcp" + environment: + POSTGRES_PASSWORD: postgres_password + healthcheck: + test: psql -c 'SELECT 1' -h localhost postgres postgres + interval: 1s + timeout: 30s + retries: 10 diff --git a/docker/Dockerfile b/docker/Dockerfile index ccfe5b5c7..2e30b0bdd 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -8,6 +8,7 @@ RUN install-php-extensions \ mongodb \ amqp \ rdkafka \ - mysqli + mysqli \ + pgsql USER php diff --git a/src/Instrumentation/PgSql/.gitattributes b/src/Instrumentation/PgSql/.gitattributes new file mode 100644 index 000000000..1676cf825 --- /dev/null +++ b/src/Instrumentation/PgSql/.gitattributes @@ -0,0 +1,12 @@ +* text=auto + +*.md diff=markdown +*.php diff=php + +/.gitattributes export-ignore +/.gitignore export-ignore +/.php-cs-fixer.php export-ignore +/phpstan.neon.dist export-ignore +/phpunit.xml.dist export-ignore +/psalm.xml.dist export-ignore +/tests export-ignore diff --git a/src/Instrumentation/PgSql/.gitignore b/src/Instrumentation/PgSql/.gitignore new file mode 100644 index 000000000..57872d0f1 --- /dev/null +++ b/src/Instrumentation/PgSql/.gitignore @@ -0,0 +1 @@ +/vendor/ diff --git a/src/Instrumentation/PgSql/.phan/config.php b/src/Instrumentation/PgSql/.phan/config.php new file mode 100644 index 000000000..6bf6f35c4 --- /dev/null +++ b/src/Instrumentation/PgSql/.phan/config.php @@ -0,0 +1,371 @@ + '8.2', + + // If enabled, missing properties will be created when + // they are first seen. If false, we'll report an + // error message if there is an attempt to write + // to a class property that wasn't explicitly + // defined. + 'allow_missing_properties' => false, + + // If enabled, null can be cast to any type and any + // type can be cast to null. Setting this to true + // will cut down on false positives. + 'null_casts_as_any_type' => false, + + // If enabled, allow null to be cast as any array-like type. + // + // This is an incremental step in migrating away from `null_casts_as_any_type`. + // If `null_casts_as_any_type` is true, this has no effect. + 'null_casts_as_array' => true, + + // If enabled, allow any array-like type to be cast to null. + // This is an incremental step in migrating away from `null_casts_as_any_type`. + // If `null_casts_as_any_type` is true, this has no effect. + 'array_casts_as_null' => true, + + // If enabled, scalars (int, float, bool, string, null) + // are treated as if they can cast to each other. + // This does not affect checks of array keys. See `scalar_array_key_cast`. + 'scalar_implicit_cast' => false, + + // If enabled, any scalar array keys (int, string) + // are treated as if they can cast to each other. + // E.g. `array` can cast to `array` and vice versa. + // Normally, a scalar type such as int could only cast to/from int and mixed. + 'scalar_array_key_cast' => true, + + // If this has entries, scalars (int, float, bool, string, null) + // are allowed to perform the casts listed. + // + // E.g. `['int' => ['float', 'string'], 'float' => ['int'], 'string' => ['int'], 'null' => ['string']]` + // allows casting null to a string, but not vice versa. + // (subset of `scalar_implicit_cast`) + 'scalar_implicit_partial' => [], + + // If enabled, Phan will warn if **any** type in a method invocation's object + // is definitely not an object, + // or if **any** type in an invoked expression is not a callable. + // Setting this to true will introduce numerous false positives + // (and reveal some bugs). + 'strict_method_checking' => false, + + // If enabled, Phan will warn if **any** type of the object expression for a property access + // does not contain that property. + 'strict_object_checking' => false, + + // If enabled, Phan will warn if **any** type in the argument's union type + // cannot be cast to a type in the parameter's expected union type. + // Setting this to true will introduce numerous false positives + // (and reveal some bugs). + 'strict_param_checking' => false, + + // If enabled, Phan will warn if **any** type in a property assignment's union type + // cannot be cast to a type in the property's declared union type. + // Setting this to true will introduce numerous false positives + // (and reveal some bugs). + 'strict_property_checking' => false, + + // If enabled, Phan will warn if **any** type in a returned value's union type + // cannot be cast to the declared return type. + // Setting this to true will introduce numerous false positives + // (and reveal some bugs). + 'strict_return_checking' => false, + + // If true, seemingly undeclared variables in the global + // scope will be ignored. + // + // This is useful for projects with complicated cross-file + // globals that you have no hope of fixing. + 'ignore_undeclared_variables_in_global_scope' => true, + + // Set this to false to emit `PhanUndeclaredFunction` issues for internal functions that Phan has signatures for, + // but aren't available in the codebase, or from Reflection. + // (may lead to false positives if an extension isn't loaded) + // + // If this is true(default), then Phan will not warn. + // + // Even when this is false, Phan will still infer return values and check parameters of internal functions + // if Phan has the signatures. + 'ignore_undeclared_functions_with_known_signatures' => true, + + // Backwards Compatibility Checking. This is slow + // and expensive, but you should consider running + // it before upgrading your version of PHP to a + // new version that has backward compatibility + // breaks. + // + // If you are migrating from PHP 5 to PHP 7, + // you should also look into using + // [php7cc (no longer maintained)](https://github.com/sstalle/php7cc) + // and [php7mar](https://github.com/Alexia/php7mar), + // which have different backwards compatibility checks. + 'backward_compatibility_checks' => false, + + // If true, check to make sure the return type declared + // in the doc-block (if any) matches the return type + // declared in the method signature. + 'check_docblock_signature_return_type_match' => false, + + // If true, make narrowed types from phpdoc params override + // the real types from the signature, when real types exist. + // (E.g. allows specifying desired lists of subclasses, + // or to indicate a preference for non-nullable types over nullable types) + // + // Affects analysis of the body of the method and the param types passed in by callers. + // + // (*Requires `check_docblock_signature_param_type_match` to be true*) + 'prefer_narrowed_phpdoc_param_type' => true, + + // (*Requires `check_docblock_signature_return_type_match` to be true*) + // + // If true, make narrowed types from phpdoc returns override + // the real types from the signature, when real types exist. + // + // (E.g. allows specifying desired lists of subclasses, + // or to indicate a preference for non-nullable types over nullable types) + // + // This setting affects the analysis of return statements in the body of the method and the return types passed in by callers. + 'prefer_narrowed_phpdoc_return_type' => true, + + // If enabled, check all methods that override a + // parent method to make sure its signature is + // compatible with the parent's. + // + // This check can add quite a bit of time to the analysis. + // + // This will also check if final methods are overridden, etc. + 'analyze_signature_compatibility' => true, + + // This setting maps case-insensitive strings to union types. + // + // This is useful if a project uses phpdoc that differs from the phpdoc2 standard. + // + // If the corresponding value is the empty string, + // then Phan will ignore that union type (E.g. can ignore 'the' in `@return the value`) + // + // If the corresponding value is not empty, + // then Phan will act as though it saw the corresponding UnionTypes(s) + // when the keys show up in a UnionType of `@param`, `@return`, `@var`, `@property`, etc. + // + // This matches the **entire string**, not parts of the string. + // (E.g. `@return the|null` will still look for a class with the name `the`, but `@return the` will be ignored with the below setting) + // + // (These are not aliases, this setting is ignored outside of doc comments). + // (Phan does not check if classes with these names exist) + // + // Example setting: `['unknown' => '', 'number' => 'int|float', 'char' => 'string', 'long' => 'int', 'the' => '']` + 'phpdoc_type_mapping' => [], + + // Set to true in order to attempt to detect dead + // (unreferenced) code. Keep in mind that the + // results will only be a guess given that classes, + // properties, constants and methods can be referenced + // as variables (like `$class->$property` or + // `$class->$method()`) in ways that we're unable + // to make sense of. + 'dead_code_detection' => false, + + // Set to true in order to attempt to detect unused variables. + // `dead_code_detection` will also enable unused variable detection. + // + // This has a few known false positives, e.g. for loops or branches. + 'unused_variable_detection' => false, + + // Set to true in order to attempt to detect redundant and impossible conditions. + // + // This has some false positives involving loops, + // variables set in branches of loops, and global variables. + 'redundant_condition_detection' => false, + + // If enabled, Phan will act as though it's certain of real return types of a subset of internal functions, + // even if those return types aren't available in reflection (real types were taken from php 7.3 or 8.0-dev, depending on target_php_version). + // + // Note that with php 7 and earlier, php would return null or false for many internal functions if the argument types or counts were incorrect. + // As a result, enabling this setting with target_php_version 8.0 may result in false positives for `--redundant-condition-detection` when codebases also support php 7.x. + 'assume_real_types_for_internal_functions' => false, + + // If true, this runs a quick version of checks that takes less + // time at the cost of not running as thorough + // of an analysis. You should consider setting this + // to true only when you wish you had more **undiagnosed** issues + // to fix in your code base. + // + // In quick-mode the scanner doesn't rescan a function + // or a method's code block every time a call is seen. + // This means that the problem here won't be detected: + // + // ```php + // false, + + // Enable or disable support for generic templated + // class types. + 'generic_types_enabled' => true, + + // Override to hardcode existence and types of (non-builtin) globals in the global scope. + // Class names should be prefixed with `\`. + // + // (E.g. `['_FOO' => '\FooClass', 'page' => '\PageClass', 'userId' => 'int']`) + 'globals_type_map' => [], + + // The minimum severity level to report on. This can be + // set to `Issue::SEVERITY_LOW`, `Issue::SEVERITY_NORMAL` or + // `Issue::SEVERITY_CRITICAL`. Setting it to only + // critical issues is a good place to start on a big + // sloppy mature code base. + 'minimum_severity' => Issue::SEVERITY_LOW, + + // Add any issue types (such as `'PhanUndeclaredMethod'`) + // to this deny-list to inhibit them from being reported. + 'suppress_issue_types' => [], + + // A regular expression to match files to be excluded + // from parsing and analysis and will not be read at all. + // + // This is useful for excluding groups of test or example + // directories/files, unanalyzable files, or files that + // can't be removed for whatever reason. + // (e.g. `'@Test\.php$@'`, or `'@vendor/.*/(tests|Tests)/@'`) + 'exclude_file_regex' => '@^vendor/.*/(tests?|Tests?)/@', + + // A list of files that will be excluded from parsing and analysis + // and will not be read at all. + // + // This is useful for excluding hopelessly unanalyzable + // files that can't be removed for whatever reason. + 'exclude_file_list' => [ + 'vendor/composer/composer/src/Composer/InstalledVersions.php' + ], + + // A directory list that defines files that will be excluded + // from static analysis, but whose class and method + // information should be included. + // + // Generally, you'll want to include the directories for + // third-party code (such as "vendor/") in this list. + // + // n.b.: If you'd like to parse but not analyze 3rd + // party code, directories containing that code + // should be added to the `directory_list` as well as + // to `exclude_analysis_directory_list`. + 'exclude_analysis_directory_list' => [ + 'vendor/', + 'proto/', + 'thrift/' + ], + + // Enable this to enable checks of require/include statements referring to valid paths. + 'enable_include_path_checks' => true, + + // The number of processes to fork off during the analysis + // phase. + 'processes' => 1, + + // List of case-insensitive file extensions supported by Phan. + // (e.g. `['php', 'html', 'htm']`) + 'analyzed_file_extensions' => [ + 'php', + ], + + // You can put paths to stubs of internal extensions in this config option. + // If the corresponding extension is **not** loaded, then Phan will use the stubs instead. + // Phan will continue using its detailed type annotations, + // but load the constants, classes, functions, and classes (and their Reflection types) + // from these stub files (doubling as valid php files). + // Use a different extension from php to avoid accidentally loading these. + // The `tools/make_stubs` script can be used to generate your own stubs (compatible with php 7.0+ right now) + // + // (e.g. `['xdebug' => '.phan/internal_stubs/xdebug.phan_php']`) + 'autoload_internal_extension_signatures' => [], + + // A list of plugin files to execute. + // + // Plugins which are bundled with Phan can be added here by providing their name (e.g. `'AlwaysReturnPlugin'`) + // + // Documentation about available bundled plugins can be found [here](https://github.com/phan/phan/tree/master/.phan/plugins). + // + // Alternately, you can pass in the full path to a PHP file with the plugin's implementation (e.g. `'vendor/phan/phan/.phan/plugins/AlwaysReturnPlugin.php'`) + 'plugins' => [ + 'AlwaysReturnPlugin', + 'PregRegexCheckerPlugin', + 'UnreachableCodePlugin', + ], + + // A list of directories that should be parsed for class and + // method information. After excluding the directories + // defined in `exclude_analysis_directory_list`, the remaining + // files will be statically analyzed for errors. + // + // Thus, both first-party and third-party code being used by + // your application should be included in this list. + 'directory_list' => [ + 'src', + 'vendor' + ], + + // A list of individual files to include in analysis + // with a path relative to the root directory of the + // project. + 'file_list' => [], +]; diff --git a/src/Instrumentation/PgSql/.php-cs-fixer.php b/src/Instrumentation/PgSql/.php-cs-fixer.php new file mode 100644 index 000000000..e35fa078c --- /dev/null +++ b/src/Instrumentation/PgSql/.php-cs-fixer.php @@ -0,0 +1,43 @@ +exclude('vendor') + ->exclude('var/cache') + ->in(__DIR__); + +$config = new PhpCsFixer\Config(); +return $config->setRules([ + 'concat_space' => ['spacing' => 'one'], + 'declare_equal_normalize' => ['space' => 'none'], + 'is_null' => true, + 'modernize_types_casting' => true, + 'ordered_imports' => true, + 'php_unit_construct' => true, + 'single_line_comment_style' => true, + 'yoda_style' => false, + '@PSR2' => true, + 'array_syntax' => ['syntax' => 'short'], + 'blank_line_after_opening_tag' => true, + 'blank_line_before_statement' => true, + 'cast_spaces' => true, + 'declare_strict_types' => true, + 'type_declaration_spaces' => true, + 'include' => true, + 'lowercase_cast' => true, + 'new_with_parentheses' => true, + 'no_extra_blank_lines' => true, + 'no_leading_import_slash' => true, + 'echo_tag_syntax' => true, + 'no_unused_imports' => true, + 'no_useless_else' => true, + 'no_useless_return' => true, + 'phpdoc_order' => true, + 'phpdoc_scalar' => true, + 'phpdoc_types' => true, + 'short_scalar_cast' => true, + 'blank_lines_before_namespace' => true, + 'single_quote' => true, + 'trailing_comma_in_multiline' => true, + ]) + ->setRiskyAllowed(true) + ->setFinder($finder); + diff --git a/src/Instrumentation/PgSql/README.md b/src/Instrumentation/PgSql/README.md new file mode 100644 index 000000000..ea89fa58c --- /dev/null +++ b/src/Instrumentation/PgSql/README.md @@ -0,0 +1,29 @@ +[![Releases](https://img.shields.io/badge/releases-purple)](https://github.com/opentelemetry-php/contrib-auto-pgsql/releases) +[![Issues](https://img.shields.io/badge/issues-pink)](https://github.com/open-telemetry/opentelemetry-php/issues) +[![Source](https://img.shields.io/badge/source-contrib-green)](https://github.com/open-telemetry/opentelemetry-php-contrib/tree/main/src/Instrumentation/PgSql) +[![Mirror](https://img.shields.io/badge/mirror-opentelemetry--php--contrib-blue)](https://github.com/opentelemetry-php/contrib-auto-pgsql) +[![Latest Version](http://poser.pugx.org/open-telemetry/opentelemetry-auto-pgsql/v/unstable)](https://packagist.org/packages/open-telemetry/opentelemetry-auto-pgsql/) +[![Stable](http://poser.pugx.org/open-telemetry/opentelemetry-auto-pgsql/v/stable)](https://packagist.org/packages/open-telemetry/opentelemetry-auto-pgsql/) + +This is a read-only subtree split of https://github.com/open-telemetry/opentelemetry-php-contrib. + +# OpenTelemetry pgsql auto-instrumentation + +Please read https://opentelemetry.io/docs/instrumentation/php/automatic/ for instructions on how to +install and configure the extension and SDK. + +## Overview + +Auto-instrumentation hooks are registered via Composer, and spans will automatically be created for the following pgsql functions: + +* `pg_connect` +* `pg_query` +* `pg_query_params` + +## Configuration + +The extension can be disabled via [runtime configuration](https://opentelemetry.io/docs/instrumentation/php/sdk/#configuration): + +```shell +OTEL_PHP_DISABLED_INSTRUMENTATIONS=pgsql +``` diff --git a/src/Instrumentation/PgSql/_register.php b/src/Instrumentation/PgSql/_register.php new file mode 100644 index 000000000..c716af9c8 --- /dev/null +++ b/src/Instrumentation/PgSql/_register.php @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + tests/Unit + + + tests/Integration + + + + + + src + + + + diff --git a/src/Instrumentation/PgSql/psalm.xml.dist b/src/Instrumentation/PgSql/psalm.xml.dist new file mode 100644 index 000000000..5a04b34d7 --- /dev/null +++ b/src/Instrumentation/PgSql/psalm.xml.dist @@ -0,0 +1,17 @@ + + + + + + + + + + diff --git a/src/Instrumentation/PgSql/src/PgSqlInstrumentation.php b/src/Instrumentation/PgSql/src/PgSqlInstrumentation.php new file mode 100644 index 000000000..c6aa1287d --- /dev/null +++ b/src/Instrumentation/PgSql/src/PgSqlInstrumentation.php @@ -0,0 +1,184 @@ +url(), + ); + + $tracker = new PgSqlTracker(); + + hook( + null, + 'pg_connect', + /** + * @param array{0: string, 1?: int} $params + * @param non-empty-string $function + */ + pre: static function (mixed $obj, array $params, ?string $class, string $function, ?string $filename, ?int $lineno) use ($instrumentation) { + self::beginSpan($instrumentation, $function, $filename, $lineno); + }, + /** + * @param array{0: string, 1?: int} $params + */ + post: static function (mixed $obj, array $params, Connection|false $returnValue, ?Throwable $exception) use ($tracker) { + $connection = null; + $attributes = []; + + if ($returnValue !== false) { + $connection = $returnValue; + $port = pg_port($connection); + + $attributes = [ + TraceAttributes::DB_NAMESPACE => pg_dbname($connection), + TraceAttributes::DB_SYSTEM_NAME => 'postgresql', + TraceAttributes::SERVER_ADDRESS => pg_host($connection), + TraceAttributes::SERVER_PORT => $port ? (int) $port : null, + ]; + + $tracker->trackConnectionAttributes($connection, $attributes); + } + + self::endSpan($connection, $returnValue, $attributes); + } + ); + + hook( + null, + 'pg_query', + /** + * @param array{Connection, string}|array{string} $params + * @param non-empty-string $function + */ + pre: static function (mixed $obj, array $params, ?string $class, string $function, ?string $filename, ?int $lineno) use ($instrumentation, $tracker) { + if (count($params) < 2) { + array_unshift($params, null); + } + + /** @var ?Connection $connection */ + list($connection) = $params; + $attributes = $connection ? $tracker->trackedAttributesForConnection($connection) : []; + self::beginSpan($instrumentation, $function, $filename, $lineno, $attributes); + }, + /** + * @param array{Connection, string}|array{string} $params + */ + post: static function (mixed $obj, array $params, Result|false $returnValue, ?Throwable $exception) { + if (count($params) < 2) { + array_unshift($params, null); + } + + /** @var ?Connection $connection */ + list($connection) = $params; + $attributes = $returnValue !== false ? [TraceAttributes::DB_RESPONSE_RETURNED_ROWS => pg_num_rows($returnValue)] : []; + self::endSpan($connection, $returnValue, $attributes); + } + ); + + hook( + null, + 'pg_query_params', + /** + * @param array{Connection, string, array}|array{string, array} $params + * @param non-empty-string $function + */ + pre: static function (mixed $obj, array $params, ?string $class, string $function, ?string $filename, ?int $lineno) use ($instrumentation, $tracker) { + if (count($params) < 3) { + array_unshift($params, null); + } + + /** + * @var ?Connection $connection + * @var string $query + * @var array $queryParams + */ + list($connection, $query, $queryParams) = $params; + + $attributes = $connection ? $tracker->trackedAttributesForConnection($connection) : []; + $attributes[TraceAttributes::DB_QUERY_TEXT] = mb_convert_encoding($query, 'UTF-8'); + + foreach ($queryParams as $i => $queryParam) { + $attributes[TraceAttributes::DB_QUERY_PARAMETER . ".$i"] = mb_convert_encoding((string) $queryParam, 'UTF-8'); + } + + self::beginSpan($instrumentation, $function, $filename, $lineno, $attributes); + }, + /** + * @param array{Connection, string, array}|array{string, array} $params + */ + post: static function (mixed $obj, array $params, Result|false $returnValue, ?Throwable $exception) { + if (count($params) < 3) { + array_unshift($params, null); + } + + /** @var ?Connection $connection */ + list($connection) = $params; + $attributes = $returnValue !== false ? [TraceAttributes::DB_RESPONSE_RETURNED_ROWS => pg_num_rows($returnValue)] : []; + self::endSpan($connection, $returnValue, $attributes); + } + ); + } + + /** + * @param non-empty-string $function + * @param array $attributes + */ + private static function beginSpan(CachedInstrumentation $instrumentation, string $function, ?string $filename, ?int $lineno, array $attributes = []): void + { + $span = $instrumentation->tracer() + ->spanBuilder($function) + ->setSpanKind(SpanKind::KIND_CLIENT) + ->setAttribute(TraceAttributes::CODE_FUNCTION_NAME, $function) + ->setAttribute(TraceAttributes::CODE_FILE_PATH, $filename) + ->setAttribute(TraceAttributes::CODE_LINE_NUMBER, $lineno) + ->setAttributes($attributes) + ->startSpan(); + + Context::storage()->attach($span->storeInContext(Context::getCurrent())); + } + + /** + * @param array $attributes + */ + private static function endSpan(?Connection $connection, Connection|Result|bool $returnValue, array $attributes = []): void + { + $scope = Context::storage()->scope(); + if (!$scope) { + return; + } + + $scope->detach(); + + $span = Span::fromContext($scope->context()); + $span->setAttributes($attributes); + + if ($returnValue === false) { + $description = $connection ? pg_last_error($connection) : null; + $span->setStatus(StatusCode::STATUS_ERROR, $description); + } + + $span->end(); + } +} diff --git a/src/Instrumentation/PgSql/src/PgSqlTracker.php b/src/Instrumentation/PgSql/src/PgSqlTracker.php new file mode 100644 index 000000000..d1f8c5325 --- /dev/null +++ b/src/Instrumentation/PgSql/src/PgSqlTracker.php @@ -0,0 +1,39 @@ +> + */ + private WeakMap $connectionToAttributesMap; + + public function __construct() + { + /** @psalm-suppress PropertyTypeCoercion */ + $this->connectionToAttributesMap = new WeakMap(); + } + + /** + * @param array $attributes + */ + public function trackConnectionAttributes(Connection $connection, array $attributes): void + { + $this->connectionToAttributesMap[$connection] = $attributes; + } + + /** + * @return array + */ + public function trackedAttributesForConnection(Connection $connection): array + { + /** @psalm-var array */ + return $this->connectionToAttributesMap[$connection] ?? []; + } +} diff --git a/src/Instrumentation/PgSql/tests/Integration/PgSqlInstrumentationTest.php b/src/Instrumentation/PgSql/tests/Integration/PgSqlInstrumentationTest.php new file mode 100644 index 000000000..1a1c1c392 --- /dev/null +++ b/src/Instrumentation/PgSql/tests/Integration/PgSqlInstrumentationTest.php @@ -0,0 +1,229 @@ +storage = new ArrayObject(); + $tracerProvider = new TracerProvider( + new SimpleSpanProcessor( + new InMemoryExporter($this->storage) + ) + ); + + $this->scope = Configurator::create() + ->withTracerProvider($tracerProvider) + ->activate(); + + $this->pgSqlHost = getenv('PGSQL_HOST') ?: '127.0.0.1'; + $this->pgSqlPort = (int) (getenv('PGSQL_PORT') ?: '5432'); + + $this->user = getenv('PGSQL_USER') ?: 'postgres'; + $this->passwd = getenv('PGSQL_PASSWD') ?: null; + $this->database = getenv('PGSQL_DATABASE') ?: 'postgres'; + } + + public function tearDown(): void + { + $this->scope->detach(); + } + + public static function pgConnectProvider(): array + { + return [ + [null, true], + ['0.0.0.0', false], + ]; + } + + #[DataProvider('pgConnectProvider')] + public function testPgConnect(?string $hostOverride, bool $expectSuccess): void + { + $this->assertCount(0, $this->storage); + + if ($expectSuccess) { + $this->assertNotFalse(pg_connect($this->getConnectionString($hostOverride))); + } else { + $this->assertFalse(@pg_connect($this->getConnectionString($hostOverride))); + } + + $this->assertCount(1, $this->storage); + $span = $this->storage->offsetGet(0); + + $this->assertSame('pg_connect', $span->getName()); + $this->assertSame(SpanKind::KIND_CLIENT, $span->getKind()); + + if ($expectSuccess) { + $this->assertConnectionAttributes($span->getAttributes()); + } else { + $this->assertSame(StatusCode::STATUS_ERROR, $span->getStatus()->getCode()); + } + } + + public static function pgQueryProvider(): array + { + return [ + ['SELECT 1', true, false], + ['SELECT 1', true, true], + ["SELECT 'abc", false, false], + ]; + } + + #[DataProvider('pgQueryProvider')] + public function testPgQuery(string $query, bool $expectSuccess, bool $useDefaultConnection): void + { + $this->assertCount(0, $this->storage); + + $connection = pg_connect($this->getConnectionString()); + $this->assertNotFalse($connection); + + if ($useDefaultConnection) { + if ($expectSuccess) { + $this->assertNotFalse(@pg_query($query)); + } else { + $this->assertFalse(@pg_query($query)); + } + } else { + if ($expectSuccess) { + $this->assertNotFalse(pg_query($connection, $query)); + } else { + $this->assertFalse(@pg_query($connection, $query)); + } + } + + pg_close($connection); + + $this->assertCount(2, $this->storage); + $span = $this->storage->offsetGet(1); + + $this->assertSame('pg_query', $span->getName()); + $this->assertSame(SpanKind::KIND_CLIENT, $span->getKind()); + + if (!$useDefaultConnection) { + $this->assertConnectionAttributes($span->getAttributes()); + } + + // Per https://opentelemetry.io/docs/specs/semconv/database/database-spans/#sanitization-of-dbquerytext: + // "The db.query.text SHOULD be collected by default only if there is sanitization that excludes sensitive information." + $this->assertFalse($span->getAttributes()->has(TraceAttributes::DB_QUERY_TEXT)); + + if ($expectSuccess) { + $this->assertSame(1, $span->getAttributes()->get(TraceAttributes::DB_RESPONSE_RETURNED_ROWS)); + } else { + $this->assertFalse($span->getAttributes()->has(TraceAttributes::DB_RESPONSE_RETURNED_ROWS)); + $this->assertSame(StatusCode::STATUS_ERROR, $span->getStatus()->getCode()); + $this->assertNotEmpty($span->getStatus()->getDescription()); + } + } + + public static function pgQueryParamsProvider(): array + { + return [ + ['SELECT $1, $2', [1, 2], true, false], + ['SELECT $1, $2', [1, 2], true, true], + ['SELECT $1, $2, $3', [1, 2], false, false], + ]; + } + + #[DataProvider('pgQueryParamsProvider')] + public function testPgQueryParams(string $query, array $params, bool $expectSuccess, bool $useDefaultConnection): void + { + $this->assertCount(0, $this->storage); + + $connection = pg_connect($this->getConnectionString()); + $this->assertNotFalse($connection); + + if ($useDefaultConnection) { + if ($expectSuccess) { + $this->assertNotFalse(@pg_query_params($query, $params)); + } else { + $this->assertFalse(@pg_query_params($query, $params)); + } + } else { + if ($expectSuccess) { + $this->assertNotFalse(pg_query_params($connection, $query, $params)); + } else { + $this->assertFalse(@pg_query_params($connection, $query, $params)); + } + } + + pg_close($connection); + + $this->assertCount(2, $this->storage); + $span = $this->storage->offsetGet(1); + + $this->assertSame('pg_query_params', $span->getName()); + $this->assertSame(SpanKind::KIND_CLIENT, $span->getKind()); + + if (!$useDefaultConnection) { + $this->assertConnectionAttributes($span->getAttributes()); + } + + $this->assertSame($query, $span->getAttributes()->get(TraceAttributes::DB_QUERY_TEXT)); + + foreach ($params as $i => $v) { + $attribute = TraceAttributes::DB_QUERY_PARAMETER . ".$i"; + $this->assertSame((string) $v, $span->getAttributes()->get($attribute)); + } + + if ($expectSuccess) { + $this->assertSame(1, $span->getAttributes()->get(TraceAttributes::DB_RESPONSE_RETURNED_ROWS)); + } else { + $this->assertFalse($span->getAttributes()->has(TraceAttributes::DB_RESPONSE_RETURNED_ROWS)); + $this->assertSame(StatusCode::STATUS_ERROR, $span->getStatus()->getCode()); + $this->assertNotEmpty($span->getStatus()->getDescription()); + } + } + + private function getConnectionString(?string $hostOverride = null): string + { + $host = str_replace("'", "\\'", $hostOverride ?: $this->pgSqlHost); + $port = (string) $this->pgSqlPort; + $dbname = str_replace("'", "\\'", $this->database); + $user = str_replace("'", "\\'", $this->user); + + $str = "host='$host' port='$port' dbname='$dbname' user='$user'"; + + if ($this->passwd) { + $password = str_replace("'", "\\'", $this->passwd); + $str .= " password='$password'"; + } + + return $str; + } + + private function assertConnectionAttributes(AttributesInterface $attributes): void + { + $this->assertSame($this->database, $attributes->get(TraceAttributes::DB_NAMESPACE)); + $this->assertSame('postgresql', $attributes->get(TraceAttributes::DB_SYSTEM_NAME)); + $this->assertSame($this->pgSqlHost, $attributes->get(TraceAttributes::SERVER_ADDRESS)); + $this->assertSame($this->pgSqlPort, $attributes->get(TraceAttributes::SERVER_PORT)); + } +} diff --git a/src/Instrumentation/PgSql/tests/Unit/.gitkeep b/src/Instrumentation/PgSql/tests/Unit/.gitkeep new file mode 100644 index 000000000..e69de29bb