Implement exporterfactory

composer.json

@@ -10,8 +10,9 @@
         "grpc/grpc": "^1.30",
         "google/protobuf": "^v3.3.0",
         "psr/http-client-implementation": "^1.0",
-        "psr/http-factory-implementation": "^1.0"
-    },
+        "psr/http-factory-implementation": "^1.0",
+        "nyholm/dsn": "^2.0.0"
+        },
     "authors": [
         {
             "name": "Bob Strecansky",
@@ -59,6 +60,7 @@
         "guzzlehttp/guzzle": "^7.3",
         "guzzlehttp/psr7": "^2.0@RC",
         "symfony/http-client": "^5.2",
-        "nyholm/psr7": "^1.4"
+        "nyholm/psr7": "^1.4",
+        "nyholm/dsn": "^2.0.0"
     }
 }

sdk/Trace/ExporterFactory.php

@@ -0,0 +1,166 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Sdk\Trace;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\Psr7\HttpFactory;
+use Nyholm\Dsn\DsnParser;
+use OpenTelemetry\Contrib\Jaeger\Exporter as JaegerExporter;
+use OpenTelemetry\Contrib\Newrelic\Exporter as NewrelicExporter;
+use OpenTelemetry\Contrib\Otlp\Exporter as OtlpExporter;
+use OpenTelemetry\Contrib\OtlpGrpc\Exporter as OtlpGrpcExporter;
+use OpenTelemetry\Contrib\Zipkin\Exporter as ZipkinExporter;
+use OpenTelemetry\Contrib\ZipkinToNewrelic\Exporter as ZipkinToNewrelicExporter;
+
+class ExporterFactory
+{
+    private $name;
+    private $allowedExporters = ['jaeger' => true, 'zipkin' => true, 'newrelic' => true, 'otlp' => true, 'otlpgrpc' => true, 'zipkintonewrelic' => true];
+
+    public function __construct(string $name)
+    {
+        $this->name = $name;
+    }
+
+    /**
+      * Returns the coresponding Exporter via the configuration string
+      *
+      * @param string $configurationString String containing unextracted information for Exporter creation
+      * Should follow the format: contribType+baseUrl?option1=a
+      * Query string is optional and based on the Exporter
+      */
+    public function fromConnectionString(string $configurationString)
+    {
+        $strArr = explode('+', $configurationString);
+        // checks if input is given with the format type+baseUrl
+        if (sizeof($strArr) != 2) {
+            return null;
+        }
+
+        $contribName = strtolower($strArr[0]);
+        $endpointUrl = $strArr[1];
+
+        if (!$this->isAllowed($contribName)) {
+            return null;
+        }
+
+        $args = [];
+        // endpoint is only parsed if it is provided
+        $dsn = empty($endpointUrl) ? '' : DsnParser::parse($endpointUrl);
+        $endpointUrl = $this->parseBaseUrl($dsn);
+        // parameters are only retrieved if there was an endpoint given
+        $args = empty($dsn) ? '' : $dsn->getParameters();
+
+        switch ($contribName) {
+            case 'jaeger':
+                return $exporter = $this->generateJaeger($endpointUrl);
+            case 'zipkin':
+                return $exporter = $this->generateZipkin($endpointUrl);
+            case 'newrelic':
+                return $exporter = $this->generateNewrelic($endpointUrl, $args['licenseKey'] ?? null);
+            case 'otlp':
+                return $exporter = $this->_generateOtlp();
+            case 'otlpgrpc':
+                return $exporter = $this->generateOtlpGrpc();
+            case 'zipkintonewrelic':
+                return $exporter = $this->generateZipkinToNewrelic($endpointUrl, $args['licenseKey'] ?? null);
+            }
+    }
+
+    private function isAllowed(string $exporter)
+    {
+        return array_key_exists($exporter, $this->allowedExporters) && $this->allowedExporters[$exporter];
+    }
+
+    // constructs the baseUrl from
+    private function parseBaseUrl($dsn)
+    {
+        if ($dsn == false) {
+            return null;
+        }
+        $parsedUrl = '';
+        $parsedUrl .= empty($dsn->getScheme()) ? '' : $dsn->getScheme() . '://';
+        $parsedUrl .= empty($dsn->getHost()) ? '' : $dsn->getHost();
+        $parsedUrl .= empty($dsn->getPort()) ? '' : ':' . $dsn->getPort();
+        $parsedUrl .= empty($dsn->getPath()) ? '' : $dsn->getPath();
+
+        return $parsedUrl;
+    }
+
+    private function generateJaeger(string $endpointUrl)
+    {
+        $exporter = new JaegerExporter(
+            $this->name,
+            $endpointUrl,
+            new Client(),
+            new HttpFactory(),
+            new HttpFactory()
+        );
+
+        return $exporter;
+    }
+    private function generateZipkin(string $endpointUrl)
+    {
+        $exporter = new ZipkinExporter(
+            $this->name,
+            $endpointUrl,
+            new Client(),
+            new HttpFactory(),
+            new HttpFactory()
+        );
+
+        return $exporter;
+    }
+    private function generateNewrelic(string $endpointUrl, $licenseKey)
+    {
+        if ($licenseKey == false) {
+            return null;
+        }
+        $exporter = new NewrelicExporter(
+            $this->name,
+            $endpointUrl,
+            $licenseKey,
+            new Client(),
+            new HttpFactory(),
+            new HttpFactory()
+        );
+
+        return $exporter;
+    }
+
+    private function _generateOtlp()
+    {
+        $exporter = new OtlpExporter(
+            $this->name,
+            new Client(),
+            new HttpFactory(),
+            new HttpFactory()
+        );
+
+        return $exporter;
+    }
+
+    private function generateOtlpGrpc()
+    {
+        return new OtlpGrpcExporter();
+    }
+
+    private function generateZipkinToNewrelic(string $endpointUrl, $licenseKey)
+    {
+        if ($licenseKey == false) {
+            return null;
+        }
+        $exporter = new ZipkinToNewrelicExporter(
+            $this->name,
+            $endpointUrl,
+            $licenseKey,
+            new Client(),
+            new HttpFactory(),
+            new HttpFactory()
+        );
+
+        return $exporter;
+    }
+}

sdk/Trace/Sampler.php

@@ -15,7 +15,7 @@
 interface Sampler
 {
     /**
-     * Returns SamplingResult.
+     * Returns the sampling Decision that will be used in Span creation.
      *
      * @param Context $parentContext Context with parent Span. The Span's SpanContext may be invalid to indicate a root span.
      * @param string $traceId TraceId of the Span to be created. It can be different from the TraceId in the SpanContext.

tests/Sdk/Unit/Trace/ExporterFactoryTest.php

@@ -0,0 +1,90 @@
+<?php
+
+declare(strict_types=1);
+
+namespace OpenTelemetry\Tests\Sdk\Unit\Trace;
+
+use OpenTelemetry\Contrib as Path;
+use OpenTelemetry\Sdk\Trace\ExporterFactory as ExporterFactory;
+use PHPUnit\Framework\TestCase;
+
+class ExporterFactoryTest extends TestCase
+{
+    /**
+     * @test
+     */
+    public function testIfExporterHasCorrectEndpoint()
+    {
+        $input = 'zipkin+http://zipkin:9411/api/v2/spans';
+        $factory = new ExporterFactory('test.zipkin');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertInstanceOf(Path\Zipkin\Exporter::class, $exporter);
+
+        $input = 'jaeger+http://jaeger:9412/api/v2/spans';
+        $factory = new ExporterFactory('test.jaeger');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertInstanceOf(Path\Jaeger\Exporter::class, $exporter);
+
+        $input = 'newrelic+https://trace-api.newrelic.com/trace/v1?licenseKey="23423423';
+        $factory = new ExporterFactory('test.newrelic');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertInstanceOf(Path\Newrelic\Exporter::class, $exporter);
+
+        $input = 'otlp+';
+        $factory = new ExporterFactory('test.otlp');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertInstanceOf(Path\Otlp\Exporter::class, $exporter);
+
+        $input = 'otlpgrpc+';
+        $factory = new ExporterFactory('test.otlpgrpc');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertInstanceOf(Path\OtlpGrpc\Exporter::class, $exporter);
+
+        $input = 'zipkintonewrelic+https://trace-api.newrelic.com/trace/v1?licenseKey="23423423';
+        $factory = new ExporterFactory('test.zipkintonewrelic');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertInstanceOf(Path\ZipkinToNewrelic\Exporter::class, $exporter);
+    }
+
+    /**
+     * @test
+     */
+    public function testInvalidInput()
+    {
+        $input = 'zipkinhttp://zipkin:9411/api/v2/spans';
+        $factory = new ExporterFactory('test.zipkin');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertNull($exporter);
+
+        $input = 'zipkin+http://zipkin:9411/api/v2/spans+extraField';
+        $factory = new ExporterFactory('test.zipkin');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertNull($exporter);
+
+        $input = 'zapkin+http://zipkin:9411/api/v2/spans';
+        $factory = new ExporterFactory('test.zipkin');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertNull($exporter);
+
+        $input = 'otlp';
+        $factory = new ExporterFactory('test.otlp');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertNull($exporter);
+    }
+
+    /**
+     * @test
+     */
+    public function testMissingLicenseKey()
+    {
+        $input = 'newrelic+https://trace-api.newrelic.com/trace/v1';
+        $factory = new ExporterFactory('test.newrelic');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertNull($exporter);
+
+        $input = 'zipkintonewrelic+https://trace-api.newrelic.com/trace/v1';
+        $factory = new ExporterFactory('test.zipkintonewrelic');
+        $exporter = $factory->fromConnectionString($input);
+        $this->assertNull($exporter);
+    }
+}