fixing hexdec on a 16 char hex number, which could actually exceed INT64

.circleci/config.yml

@@ -1,16 +1,17 @@
 unit-config: &unit-config
   steps:
     # library requires sockets extension
-    - run: sudo docker-php-ext-install sockets
+    - run: sudo apt-get install -y libgmp-dev re2c libmhash-dev libmcrypt-dev file && sudo ln -s /usr/include/x86_64-linux-gnu/gmp.h /usr/local/include/
+    - run: sudo docker-php-ext-install bcmath gmp sockets
 
     - checkout
 
     # Download and cache dependencies
     - restore_cache:
         keys:
-        - v1-dependencies-{{ checksum "composer.json" }}
+        - v1-dependencies-{{ checksum "composer.json" }}-v1
         # fallback to using the latest cache if no exact match is found
-        - v1-dependencies-
+        - v1-dependencies-v1-
 
     - run: composer install -n --prefer-dist
 

Dockerfile

@@ -19,8 +19,9 @@ WORKDIR /workspace
 
 # current user is circleci
 RUN sudo chown -R $(whoami) /workspace
-RUN sudo docker-php-ext-install sockets
+RUN sudo apt-get update && sudo apt-get install -y libgmp-dev re2c libmhash-dev libmcrypt-dev file && sudo ln -s /usr/include/x86_64-linux-gnu/gmp.h /usr/local/include/
+RUN sudo docker-php-ext-install bcmath gmp sockets
 
 RUN composer install -n --prefer-dist
 
-ENTRYPOINT []
+ENTRYPOINT []

composer.json

@@ -25,5 +25,8 @@
         "psr-4": {
             "OpenCensus\\Trace\\Exporter\\": "src/"
         }
+    },
+    "scripts": {
+        "post-dependencies-solving": "OpenCensus\\Trace\\Exporter\\Installer::checkPhpExtDependency"
     }
 }

src/Installer.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace OpenCensus\Trace\Exporter;
+
+class Installer
+{
+    public static function checkPhpExtDependency()
+    {
+        if (!extension_loaded('bcmath') && !extension_loaded('gmp')) {
+            throw new \Exception('`opencensus-php-exporter-jaeger` requires one of the two extensions to be '
+                . 'installed: `php-bcmath` or `php-gmp`');
+        }
+    }
+}

src/Jaeger/HexdecConverter.php

@@ -0,0 +1,50 @@
+<?php
+/**
+ * Copyright 2018 OpenCensus Authors
+ *
+ * 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 License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OpenCensus\Trace\Exporter\Jaeger;
+
+use OpenCensus\Trace\Exporter\Jaeger\HexdecConverterInterface;
+
+ /**
+  * Hexdec converter class. Used for converting hex string values into numbers by using
+  * `gmp` as large numbers library.
+  */
+class HexdecConverter implements HexdecConverterInterface
+{
+
+    const MAX_INT_64S = '9223372036854775807';
+
+    /**
+     * Hexdec convertion method for large numbers with limitation to PhP's signed INT64, using gmp.
+     * Warning: Method may not work with hex numbers larger than 8 'digits'.
+     *
+     * @param str $hex
+     * @return number
+     */
+    public function convert($hex)
+    {
+        $dec = 0;
+        $len = strlen($hex);
+        for ($i = 1; $i <= $len; $i++) {
+            $dec = gmp_add($dec, gmp_mul(strval(hexdec($hex[$i - 1])), gmp_pow('16', strval($len - $i))));
+        }
+        if (gmp_cmp($dec, self::MAX_INT_64S) > 0) {
+            $dec = gmp_sub(gmp_and($dec, self::MAX_INT_64S), gmp_add(self::MAX_INT_64S, '1'));
+        }
+        return intval($dec);
+    }
+}

src/Jaeger/HexdecConverterBcMath.php

@@ -0,0 +1,50 @@
+<?php
+/**
+ * Copyright 2018 OpenCensus Authors
+ *
+ * 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 License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OpenCensus\Trace\Exporter\Jaeger;
+
+use OpenCensus\Trace\Exporter\Jaeger\HexdecConverterInterface;
+
+ /**
+  * Hexdec converter class. Used for converting hex string values into numbers by using
+  * `bcmath` as large numbers library.
+  */
+class HexdecConverterBcMath implements HexdecConverterInterface
+{
+
+    const MAX_INT_64S = '9223372036854775807';
+
+    /**
+     * Hexdec convertion method for big data with limitation to PhP's signed INT64, using bcmath.
+     * Warning: Method may not work with hex numbers larger than 8 'digits'.
+     *
+     * @param str $hex
+     * @return number
+     */
+    public function convert($hex)
+    {
+        $dec = 0;
+        $len = strlen($hex);
+        for ($i = 1; $i <= $len; $i++) {
+            $dec = bcadd($dec, bcmul(strval(hexdec($hex[$i - 1])), bcpow('16', strval($len - $i))));
+        }
+        if (bccomp($dec, self::MAX_INT_64S) > 0) {
+            $dec = bcsub(bcsub($dec, self::MAX_INT_64S), bcadd(self::MAX_INT_64S, '2'));
+        }
+        return intval($dec);
+    }
+}

src/Jaeger/HexdecConverterInterface.php

@@ -0,0 +1,33 @@
+<?php
+/**
+ * Copyright 2018 OpenCensus Authors
+ *
+ * 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 License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace OpenCensus\Trace\Exporter\Jaeger;
+
+ /**
+  * Hexdec converter interface. Used for converting hex string values into numbers by using
+  * large numbers math libraries like Gmp or BCMath.
+  */
+interface HexdecConverterInterface
+{
+    /**
+     * Hexdec convertion method for large numbers with limitation to PhP's signed INT64.
+     *
+     * @param str $hex
+     * @return number
+     */
+    public function convert($hex);
+}

src/Jaeger/SpanConverter.php

@@ -35,21 +35,37 @@
  */
 class SpanConverter
 {
+
     /**
-     * Convert an OpenCensus Span to its Jaeger Thrift representation.
+     *@var HexdecConverterInterface
+     */
+    private $hexdec = null;
+
+    /**
+     * Create a new Span Converter.
      *
-     * @access private
+     * @param array $options [optional] {
+     *     @type HexdecConvertor convertor for hex values
+     * }
+     */
+    public function __construct(array $options = [])
+    {
+        $this->hexdec = empty($options['hexdecConverter']) ? new HexdecConverter() : $options['hexdecConverter'];
+    }
+
+    /**
+     * Convert an OpenCensus Span to its Jaeger Thrift representation.
      *
      * @param SpanData $span The span to convert.
      * @return Span The Jaeger Thrift Span representation.
      */
-    public static function convertSpan(SpanData $span)
+    public function convertSpan(SpanData $span)
     {
-        $startTime = self::convertTimestamp($span->startTime());
-        $endTime = self::convertTimestamp($span->endTime());
-        $spanId = hexdec($span->spanId());
-        $parentSpanId = hexdec($span->parentSpanId());
-        list($highTraceId, $lowTraceId) = self::convertTraceId($span->traceId());
+        $startTime = $this->convertTimestamp($span->startTime());
+        $endTime = $this->convertTimestamp($span->endTime());
+        $spanId = $this->hexdec->convert($span->spanId());
+        $parentSpanId = $this->hexdec->convert($span->parentSpanId());
+        list($highTraceId, $lowTraceId) = $this->convertTraceId($span->traceId());
 
         return new Span([
             'traceIdLow' => $lowTraceId,
@@ -61,15 +77,15 @@ public static function convertSpan(SpanData $span)
             'flags' => 0,
             'startTime' => $startTime,
             'duration' => $endTime - $startTime,
-            'tags' => self::convertTags($span->attributes()),
-            'logs' => self::convertLogs($span->timeEvents())
+            'tags' => $this->convertTags($span->attributes()),
+            'logs' => $this->convertLogs($span->timeEvents())
         ]);
     }
 
     /**
      * Convert an associative array of $key => $value to Jaeger Tags.
      */
-    public static function convertTags(array $attributes)
+    public function convertTags(array $attributes)
     {
         $tags = [];
         foreach ($attributes as $key => $value) {
@@ -82,33 +98,48 @@ public static function convertTags(array $attributes)
         return $tags;
     }
 
-    private static function convertLogs(array $timeEvents)
+    /**
+     *
+     * @param array $timeEvents
+     * @return array
+     */
+    private function convertLogs(array $timeEvents)
     {
         return array_map(function (TimeEvent $timeEvent) {
             if ($timeEvent instanceof Annotation) {
-                return self::convertAnnotation($timeEvent);
+                return $this->convertAnnotation($timeEvent);
             } elseif ($timeEvent instanceof MessageEvent) {
-                return self::convertMessageEvent($timeEvent);
+                return $this->convertMessageEvent($timeEvent);
             } else {
             }
         }, $timeEvents);
     }
 
-    private static function convertAnnotation(Annotation $annotation)
+    /**
+     *
+     * @param Annotation $annotation
+     * @return Log
+     */
+    private function convertAnnotation(Annotation $annotation)
     {
         return new Log([
-            'timestamp' => self::convertTimestamp($annotation->time()),
-            'fields' => self::convertTags($annotation->attributes() + [
+            'timestamp' => $this->convertTimestamp($annotation->time()),
+            'fields' => $this->convertTags($annotation->attributes() + [
                 'description' => $annotation->description()
             ])
         ]);
     }
 
-    private static function convertMessageEvent(MessageEvent $messageEvent)
+    /**
+     *
+     * @param MessageEvent $messageEvent
+     * @return Log
+     */
+    private function convertMessageEvent(MessageEvent $messageEvent)
     {
         return new Log([
-            'timestamp' => self::convertTimestamp($messageEvent->time()),
-            'fields' => self::convertTags([
+            'timestamp' => $this->convertTimestamp($messageEvent->time()),
+            'fields' => $this->convertTags([
                 'type' => $messageEvent->type(),
                 'id' => $messageEvent->id(),
                 'uncompressedSize' => $messageEvent->uncompressedSize(),
@@ -120,20 +151,23 @@ private static function convertMessageEvent(MessageEvent $messageEvent)
     /**
      * Return the given timestamp as an int in milliseconds.
      */
-    private static function convertTimestamp(\DateTimeInterface $dateTime)
+    private function convertTimestamp(\DateTimeInterface $dateTime)
     {
         return (int)((float) $dateTime->format('U.u') * 1000 * 1000);
     }
 
     /**
      * Split the provided hexId into 2 64-bit integers (16 hex chars each).
      * Returns array of 2 int values.
+     *
+     * @param str $hexId
+     * @return array
      */
-    private static function convertTraceId($hexId)
+    private function convertTraceId($hexId)
     {
         return array_slice(
             array_map(
-                'hexdec',
+                [$this->hexdec, 'convert'],
                 str_split(
                     substr(
                         str_pad($hexId, 32, "0", STR_PAD_LEFT),

src/JaegerExporter.php

@@ -36,22 +36,27 @@ class JaegerExporter implements ExporterInterface
     /**
      * @var string
      */
-    protected $host;
+    private $host;
 
     /**
      * @var int
      */
-    protected $port;
+    private $port;
 
     /**
      * @var Process
      */
-    protected $process;
+    private $process;
 
     /**
      * @var AgentIf
      */
-    protected $client;
+    private $client;
+
+    /**
+     * @var SpanConverter
+     */
+    private $spanConverter;
 
     /**
      * Create a new Jaeger Exporter.
@@ -76,9 +81,10 @@ public function __construct($serviceName, array $options = [])
         ];
         $this->host = $options['host'];
         $this->port = (int) $options['port'];
+        $this->spanConverter = empty($options['spanConverter']) ? new SpanConverter() : $options['spanConverter'];
         $this->process = new Process([
             'serviceName' => $serviceName,
-            'tags' => SpanConverter::convertTags($options['tags'])
+            'tags' => $this->spanConverter->convertTags($options['tags'])
         ]);
         $this->client = $options['client'];
     }
@@ -98,7 +104,7 @@ public function export(array $spans)
         $client = $this->client ?: new UDPClient($this->host, $this->port);
         $batch = new Batch([
             'process' => $this->process,
-            'spans' => array_map([SpanConverter::class, 'convertSpan'], $spans)
+            'spans' => array_map([$this->spanConverter, 'convertSpan'], $spans)
         ]);
 
         $client->emitBatch($batch);