├── .gitignore
├── src
    ├── Exception
    │   ├── ZabbixNetworkException.php
    │   └── ZabbixResponseException.php
    ├── Request
    │   ├── Packet.php
    │   └── Metric.php
    ├── Response.php
    └── ZabbixSender.php
├── composer.json
├── composer.lock
├── LICENSE
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | tags
2 | .php_cs.cache
3 | vendor/
4 | 
5 | 


--------------------------------------------------------------------------------
/src/Exception/ZabbixNetworkException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Zarplata\Zabbix\Exception;
4 | 
5 | class ZabbixNetworkException extends \Exception
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Exception/ZabbixResponseException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Zarplata\Zabbix\Exception;
4 | 
5 | class ZabbixResponseException extends \Exception
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "zarplata/zabbix-sender",
 3 |     "type": "library",
 4 |     "license": "MIT",
 5 |     "authors": [
 6 |         {
 7 |             "name": "Platonov Andrey",
 8 |             "email": "a.platonov@office.ngs.ru"
 9 |         }
10 |     ],
11 |     "require": {
12 |         "php": "^8.1",
13 |         "ext-sockets": "*"
14 |     },
15 |     "autoload": {
16 |         "psr-4": {
17 |             "Zarplata\\Zabbix\\": "src"
18 |         }
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
 1 | {
 2 |     "_readme": [
 3 |         "This file locks the dependencies of your project to a known state",
 4 |         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
 5 |         "This file is @generated automatically"
 6 |     ],
 7 |     "content-hash": "db6e3d5e784c8de7b3ee1249efda9556",
 8 |     "packages": [],
 9 |     "packages-dev": [],
10 |     "aliases": [],
11 |     "minimum-stability": "stable",
12 |     "stability-flags": [],
13 |     "prefer-stable": false,
14 |     "prefer-lowest": false,
15 |     "platform": {
16 |         "php": "^8.1",
17 |         "ext-sockets": "*"
18 |     },
19 |     "platform-dev": []
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Request/Packet.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zarplata\Zabbix\Request;
 4 | 
 5 | use Zarplata\Zabbix\Request\Metric as ZabbixMetric;
 6 | 
 7 | /**
 8 |  * Packet class - represents a set of Metrics
 9 |  */
10 | class Packet implements \JsonSerializable
11 | {
12 |     /**
13 |      * @var array
14 |      */
15 |     private $packet = [];
16 | 
17 |     public function __construct(string $request = 'sender data')
18 |     {
19 |         $this->packet['request'] = $request;
20 |     }
21 | 
22 |     public function addMetric(ZabbixMetric $metric): void
23 |     {
24 |         $this->packet['data'][] = $metric;
25 |     }
26 | 
27 |     public function getPacket(): array
28 |     {
29 |         return $this->packet;
30 |     }
31 | 
32 |     #[\ReturnTypeWillChange]
33 |     public function jsonSerialize(): array
34 |     {
35 |         return $this->packet;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Зарплата.ру
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/src/Request/Metric.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Zarplata\Zabbix\Request;
 4 | 
 5 | /**
 6 |  * Metric class - represents a Zabbix item (key and value)
 7 |  */
 8 | class Metric implements \JsonSerializable
 9 | {
10 |     /**
11 |      * @var string
12 |      */
13 |     private $itemKey;
14 | 
15 |     /**
16 |      * @var string
17 |      */
18 |     private $itemValue;
19 | 
20 |     /**
21 |      * @var string
22 |      */
23 |     private $hostname;
24 | 
25 |     /**
26 |      * @var int
27 |      */
28 |     private $timestamp;
29 | 
30 |     public function __construct(
31 |         string $itemKey,
32 |         string $itemValue
33 |     ) {
34 |         $this->itemKey = $itemKey;
35 |         $this->itemValue = $itemValue;
36 |         $this->hostname = gethostname();
37 |         $this->timestamp = time();
38 |     }
39 | 
40 |     /**
41 |      * Add custom hostname to metric
42 |      *
43 |      * @param string $hostname
44 |      */
45 |     public function withHostname(string $hostname): static
46 |     {
47 |         $this->hostname = $hostname;
48 |         return $this;
49 |     }
50 | 
51 |     /**
52 |      * Add custom timestamp to metric
53 |      *
54 |      * @param int $timestamp
55 |      */
56 |     public function withTimestamp(int $timestamp): static
57 |     {
58 |         $this->timestamp = $timestamp;
59 |         return $this;
60 |     }
61 | 
62 |     #[\ReturnTypeWillChange]
63 |     public function jsonSerialize(): array
64 |     {
65 |         return [
66 |             'host' => $this->hostname,
67 |             'key' => $this->itemKey,
68 |             'value' => $this->itemValue,
69 |             'clock' => $this->timestamp
70 |         ];
71 |     }
72 | }
73 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Zabbix sender
 2 | 
 3 | Zabbix sender it's a PHP implementation of Zabbix sender protocol.
 4 | With this library you can send any metric to Zabbix server.
 5 | Additional information about Zabbix sender protocol and request/response
 6 | you can be found in official documentation:
 7 |  - https://www.zabbix.com/documentation/6.4/manual/appendix/items/trapper
 8 |  - https://www.zabbix.com/documentation/6.4/manual/appendix/protocols/header_datalen
 9 | 
10 | ### Installation
11 | ```sh
12 | composer require zarplata/zabbix-sender
13 | ```
14 | 
15 | ### Usage
16 | ```php
17 | <?php
18 | 
19 | use \Zarplata\Zabbix\ZabbixSender;
20 | use \Zarplata\Zabbix\Request\Packet as ZabbixPacket;
21 | use \Zarplata\Zabbix\Request\Metric as ZabbixMetric;
22 | 
23 | // At first you must initialize ZabbixSender object
24 | // with address of Zabbix Server. If your Zabbix Server
25 | // don't listen default port (10051) you can define it in constructor
26 | // $sender = new ZabbixSender(
27 | //     $serverAddress='ZABBIX_SERVER_HOSTNAME',
28 | //     $serverPort=12345
29 | // );
30 | $sender = new ZabbixSender('ZABBIX_SERVER_HOSTNAME');
31 | 
32 | // After you define the $sender you must create ZabbixPacket
33 | // it's just accumulator of your metrics which you will add.
34 | $packet = new ZabbixPacket();
35 | 
36 | // Define your metrinc
37 | $packet->addMetric(new ZabbixMetric('my.super.text.item.key', 'OK'));
38 | $packet->addMetric(new ZabbixMetric('my.super.int.item.key', 1));
39 | 
40 | // And finally send to Zabbix Server
41 | $sender->send($packet);
42 | ```
43 | 
44 | ### Advanced usage options
45 | 
46 | Sometimes it may be necessary to provide hostname and/or timestamp 
47 | of metric. By default construction:
48 | ```php
49 | <?php
50 | 
51 | new ZabbixMetric('my.super.text.item.key', 'OK');
52 | ```
53 | take your current hostname and set object creation time as a metric timestamp.
54 | If you want define another hostname or/and timestamp you must
55 | write the following code:
56 | ```php
57 | <?php
58 | 
59 | (new ZabbixMetric('my.super.text.item.key', 'OK'))
60 |     ->withHostname('my_non_local_hostname')
61 |     ->withTimestamp(662637600); //Timestamp in past 
62 | ```
63 | 
64 | ### License
65 | 
66 | MIT.
67 | 


--------------------------------------------------------------------------------
/src/Response.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zarplata\Zabbix;
  4 | 
  5 | use Zarplata\Zabbix\Exception\ZabbixResponseException;
  6 | 
  7 | /**
  8 |  * Response class - represents a Zabbix response.
  9 |  *
 10 |  */
 11 | class Response
 12 | {
 13 |     private const SUCCESS_RESPONSE = 'success';
 14 | 
 15 |     /*
 16 |      * @var string
 17 |      */
 18 |     private $responceStatus;
 19 | 
 20 |     /**
 21 |      * @var int
 22 |      */
 23 |     private $processedItems;
 24 | 
 25 |     /**
 26 |      * @var int
 27 |      */
 28 |     private $failedItems;
 29 | 
 30 |     /**
 31 |      * @var int
 32 |      */
 33 |     private $totalItems;
 34 | 
 35 |     /**
 36 |      * @var float
 37 |      */
 38 |     private $secondSpent;
 39 |     
 40 |     public function __construct(array $response)
 41 |     {
 42 |         $this->parseZabbixResponse($response);
 43 |     }
 44 | 
 45 |     public function isSuccess(): bool
 46 |     {
 47 |         return $this->responceStatus === self::SUCCESS_RESPONSE;
 48 |     }
 49 | 
 50 |     public function getProcessedCount(): int
 51 |     {
 52 |         return $this->processedItems;
 53 |     }
 54 | 
 55 |     public function getFailedCount(): int
 56 |     {
 57 |         return $this->failedItems;
 58 |     }
 59 | 
 60 |     public function getTotalCount(): int
 61 |     {
 62 |         return $this->totalItems;
 63 |     }
 64 | 
 65 |     /**
 66 |      * Parse array to Response class properties
 67 |      *
 68 |      * This method takes array of values through argument
 69 |      * check required fields - `response` and `info` and
 70 |      * trying to find information about processed items
 71 |      * to zabbix server through reqular expression.
 72 |      *
 73 |      * @param array $response
 74 |      *
 75 |      * @return void
 76 |      *
 77 |      * @throws ZabbixResponseException
 78 |      */
 79 |     private function parseZabbixResponse(array $response)
 80 |     {
 81 |         if (!isset($response['response'])) {
 82 |             throw new ZabbixResponseException(
 83 |                 'invalid zabbix server response, missing `response` field'
 84 |             );
 85 |         }
 86 | 
 87 |         $this->responceStatus = $response['response'];
 88 | 
 89 |         if (!isset($response['info'])) {
 90 |             throw new ZabbixResponseException(
 91 |                 'invalid zabbix server response, missing `info` field'
 92 |             );
 93 |         }
 94 | 
 95 |         $pattern = '/\w+: (\d+); \w+: (\d+); \w+: (\d+); [a-z ]+: (\d+\.\d+)/';
 96 |         $matches = [];
 97 | 
 98 |         $matched = preg_match(
 99 |             $pattern,
100 |             $response['info'],
101 |             $matches
102 |         );
103 | 
104 |         switch (true) {
105 |             case $matched === false:
106 |                 throw new ZabbixResponseException(
107 |                     sprintf(
108 |                         "can't decode info into values, preg_match error: %d",
109 |                         preg_last_error()
110 |                     )
111 |                 );
112 | 
113 |             case $matched === 0:
114 |                 throw new ZabbixResponseException(
115 |                     sprintf(
116 |                         "pattern '%s' didn't satisfy to subject '%s'",
117 |                         $pattern,
118 |                         $response['info']
119 |                     )
120 |                 );
121 | 
122 |             default:
123 |                 break;
124 |         }
125 | 
126 |         /*
127 |          * $matches must contains the following values:
128 |          *
129 |          * $matches[0] - whole matched string for example:
130 |          * processed: 2; failed: 0; total: 2; seconds spent: 0.000059
131 |          *
132 |          * $matches[1] - 2 (processed)
133 |          * $matches[2] - 0 (failed)
134 |          * $matches[3] - 2 (total)
135 |          * $matches[4] - 0.000059 (secods spent)
136 |          */
137 |         $this->processedItems = intval($matches[1]);
138 |         $this->failedItems = intval($matches[2]);
139 |         $this->totalItems = intval($matches[3]);
140 |         $this->secondSpent = floatval($matches[4]);
141 |     }
142 | }
143 | 


--------------------------------------------------------------------------------
/src/ZabbixSender.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Zarplata\Zabbix;
  4 | 
  5 | use Zarplata\Zabbix\Request\Packet as ZabbixPacket;
  6 | use Zarplata\Zabbix\Response as ZabbixResponse;
  7 | use Zarplata\Zabbix\Exception\ZabbixNetworkException;
  8 | use Zarplata\Zabbix\Exception\ZabbixResponseException;
  9 | 
 10 | class ZabbixSender
 11 | {
 12 |     /**
 13 |      * Instance instances array 
 14 |      *
 15 |      * @var array 
 16 |      */
 17 |     protected static $instances = array();
 18 | 
 19 |     /**
 20 |      *  Zabbix protocol header
 21 |      *
 22 |      *  @var string
 23 |      */
 24 |     private const HEADER = 'ZBXD';
 25 | 
 26 |     /**
 27 |      *  Zabbix protocol version
 28 |      *
 29 |      *  @var int
 30 |      */
 31 |     private const VERSION = 1;
 32 | 
 33 |     /**
 34 |      * Zabbix server response header length
 35 |      * https://www.zabbix.com/documentation/3.4/manual/appendix/protocols/header_datalen
 36 |      *
 37 |      * @var int
 38 |      */
 39 |     private const RESPONSE_HEADER_LENGTH = 13;
 40 | 
 41 |     /**
 42 |      *  @var string
 43 |      */
 44 |     private $serverAddress;
 45 | 
 46 |     /**
 47 |      *  @var int
 48 |      */
 49 |     private $serverPort;
 50 | 
 51 |     /**
 52 |      * @var ZabbixPacket
 53 |      */
 54 |     private $packet;
 55 | 
 56 |     /**
 57 |      * @var bool Disable send operation
 58 |      */
 59 |     private $disable = false;
 60 | 
 61 |     /**
 62 |      * Create singletone object
 63 |      *
 64 |      * @param string $name Name of object
 65 |      * 
 66 |      * @return ZabbixSender instance 
 67 |      */
 68 |     public static function instance($name = 'default')
 69 |     {
 70 |         if (!isset(self::$instances[$name])) {
 71 |             self::$instances[$name] = new static($name);
 72 |         }
 73 | 
 74 |         return self::$instances[$name];
 75 |     }
 76 | 
 77 |     public function __construct(
 78 |         string $serverAddress,
 79 |         int $serverPort=10051
 80 |     ) {
 81 |         $this->serverAddress = $serverAddress;
 82 |         $this->serverPort = $serverPort;
 83 |     }
 84 | 
 85 |     /**
 86 |      * Configure connection parameters to Zabbix server 
 87 |      *
 88 |      * @param array $options Configuration options 
 89 |      *
 90 |      * @return Configurated instance
 91 |      */
 92 |     public function configure(array $options = array()) 
 93 |     {
 94 |         if (isset($options['server_address'])) {
 95 |             $this->serverAddress = $options['server_address'];
 96 |         }
 97 | 
 98 |         if (isset($options['server_port'])) {
 99 |             $this->serverPort = intval($options['server_port']);
100 |         }
101 | 
102 |         if (isset($options['disable'])) {
103 |             $this->disable = boolval($options['disable']);
104 |         }
105 | 
106 |         return $this;
107 |     }
108 | 
109 |     /**
110 |      * Disable sender functionality. It may be necessary if you want
111 |      * switch off send metrics but you don't want remove the code 
112 |      * from your project.
113 |      *
114 |      * @return void
115 |      */
116 |     public function disable() {
117 |         $this->disable = true;
118 |     }
119 | 
120 |     /**
121 |      * Enable sender functionality. This is reverse operation of `disable()`
122 |      *
123 |      * @return void
124 |      */
125 |     public function enable() {
126 |         $this->disable = false;
127 |     }
128 | 
129 |     /**
130 |      * Send packet of metrics to Zabbix server through network socket
131 |      *
132 |      *
133 |      * @param ZabbixPacket $packet
134 |      *
135 |      * @return void
136 |      *
137 |      * @throws Exception
138 |      * @throws ZabbixNetworkException
139 |      */
140 |     public function send(ZabbixPacket $packet)
141 |     {
142 |         if ($this->disable) {
143 |             return;
144 |         }
145 | 
146 |         $payload = $this->makePayload($packet);
147 |         $payloadLength = strlen($payload);
148 | 
149 |         $socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP);
150 | 
151 |         if (!$socket) {
152 |             throw new \Exception("can't create TCP socket");
153 |         }
154 | 
155 |         $socketConnected = socket_connect(
156 |             $socket,
157 |             $this->serverAddress,
158 |             $this->serverPort
159 |         );
160 | 
161 |         if (!$socketConnected) {
162 |             throw new ZabbixNetworkException(
163 |                 sprintf(
164 |                     "can't connect to %s:%d",
165 |                     $this->serverAddress,
166 |                     $this->serverPort
167 |                 )
168 |             );
169 |         }
170 | 
171 |         $bytesCount= socket_send(
172 |             $socket,
173 |             $payload,
174 |             $payloadLength,
175 |             0
176 |         );
177 | 
178 |         switch (true) {
179 |             case !$bytesCount:
180 |                 throw new ZabbixNetworkException(
181 |                     sprintf(
182 |                         "can't send %d bytes to zabbix server %s:%d",
183 |                         $payloadLength,
184 |                         $this->serverAddress,
185 |                         $this->serverPort
186 |                     )
187 |                 );
188 | 
189 |             case $bytesCount != $payloadLength:
190 |                 throw new ZabbixNetworkException(
191 |                     sprintf(
192 |                         "incorrect count of bytes %s sended, expected: %d",
193 |                         $bytesCount,
194 |                         $payloadLength
195 |                     )
196 |                 );
197 | 
198 |             default:
199 |                 break;
200 |         }
201 | 
202 |         $this->checkResponse($socket);
203 |     }
204 | 
205 |     /**
206 |      * Make payload for Zabbix server with special Zabbix header
207 |      * and datalen
208 |      *
209 |      * https://www.zabbix.com/documentation/current/en/manual/appendix/protocols/header_datalen
210 |      */
211 |     private function makePayload(ZabbixPacket $packet): string
212 |     {
213 |         $encodedPacket = json_encode($packet);
214 |         return self::zbxCreateHeader(strlen($encodedPacket)) . $encodedPacket;
215 |     }
216 | 
217 |     /**
218 |      * Zabbix Packet Header
219 |      *
220 |      */
221 |     public static function zbxCreateHeader(int $plain_data_size, int|null $compressed_data_size = null): string
222 |     {
223 |         $flags = self::VERSION;
224 |         if ($compressed_data_size === null) {
225 |             $datalen = $plain_data_size;
226 |             $reserved = 0;
227 |         } else {
228 |             $flags |= 0x02;
229 |             $datalen = $compressed_data_size;
230 |             $reserved = $plain_data_size;
231 |         }
232 |         return self::HEADER . chr($flags) . pack("VV", $datalen, $reserved);
233 |     }
234 | 
235 |     /**
236 |      * Check response from Zabbix server
237 |      *
238 |      * @param resource $socket
239 |      *
240 |      * @return void
241 |      *
242 |      * @throws ZabbixResponseException
243 |      * @throws ZabbixNetworkException
244 |      */
245 |     private function checkResponse($socket)
246 |     {
247 |         $responseBuffer = "";
248 |         $responseBufferLength = 2048;
249 | 
250 |         $bytesCount = socket_recv(
251 |             $socket,
252 |             $responseBuffer,
253 |             $responseBufferLength,
254 |             0
255 |         );
256 | 
257 |         if (!$bytesCount) {
258 |             throw new ZabbixNetworkException(
259 |                 "can't receive response from socket"
260 |             );
261 |         }
262 | 
263 |         $responseWithoutHeader = substr(
264 |             $responseBuffer,
265 |             self::RESPONSE_HEADER_LENGTH
266 |         );
267 |         $response = json_decode(
268 |             $responseWithoutHeader,
269 |             true
270 |         );
271 | 
272 |         switch (true) {
273 |             case $response === null:
274 |             case $response === false:
275 |                 throw new ZabbixResponseException(
276 |                     sprintf(
277 |                         "can't decode zabbix server response %s, reason: %s",
278 |                         $responseWithoutHeader,
279 |                         json_last_error_msg()
280 |                     )
281 |                 );
282 | 
283 |             default:
284 |                 break;
285 |         }
286 | 
287 |         $zabbixResponse = new ZabbixResponse($response);
288 | 
289 |         if (!$zabbixResponse->isSuccess()) {
290 |             throw new ZabbixResponseException(
291 |                 'zabbix server returned non-successfull response'
292 |             );
293 |         }
294 |     }
295 | }
296 | 


--------------------------------------------------------------------------------