LogicMonitor Data Publisher is an integrated service in the Collector that enables you to extract and send real-time DataSource metrics from the Collector to HTTPS endpoint (a third-party destination) for further analytics. This feature enables the Collector to push the metrics to other data sinks in parallel to transmitting the data to the LogicMonitor portal. LogicMonitor Data Publisher sends metrics over any HTTPS-defined endpoint using an HTTPS receiver.

When the HTTPS receiver is integrated with the Collector, LogicMonitor Data Publisher automatically shares the metrics data. The following steps outline the service workflow:

  1. Enable and configure the HTTPS receiver in the agent.conf settings
  2. Restart the Collector to start the LogicMonitor Data Publisher service.
  3. The LogicMonitor Data Publisher collects and converts metrics data into a standard OTLP-formatted JSON string.
  4. The Data Publisher sends the formatted data to the receiver—HTTPS endpoint.

Requirements for Using LogicMonitor Data Publisher for HTTPS Receiver

To use LogicMonitor Data Publisher for HTTPS receiver, you need the following:

  • HTTPS server compatible with HTTPS v1.
  • EA Collector 37.300 or later installed on your machine.
  • The metrics.proto version v1.0.0 to read and convert metrics data in the OTLP-formatted JSON string. For more information, see metrics.proto GitHub documentation.

HTTPS Receiver Property Configurations

In the agent.conf settings, configure the following properties:

PropertyDescription
enable.collector.publisher(Mandatory) To enable the LogicMonitor Data Publisher service, set the value to true. By default, the value is set to false
agent.publisher.name(Mandatory) To enable the HTTPS publisher, set the value to http or HTTP.
publisher.http.url(Mandatory) Provide the https url to which the data is sent.
publisher.dequeue.countDefine the number of DataSourceInstances raw or metrics data that can be sent per https request. The default value is set to 5.
agent.publisher.enable.authBy default, the HTTPS request sends data in the noAuth mode (that is, in plain text). To enable the Auth mode, set the value to true. Currently, Basic and Bearer token-based authentication is supported.
publisher.http.bearer.tokenFor token-based authentication, enter your bearer token.
publisher.http.auth.userIf you set agent.publisher.enable.auth=true, enter the Basic authentication username.
publisher.http.auth.passwordIf you set agent.publisher.enable.auth=true, enter the Basic authentication password.
publisher.http.proxy.enableTo send data to the HTTPS endpoint using a proxy server, set this property to true.
publisher.http.proxy.hostSpecify the proxy host url.
publisher.http.proxy.portSpecify the proxy port.
publisher.http.proxy.userIf proxy is configured with a username, enter the proxy username.
publisher.http.proxy.passIf proxy is configured with a password, enter the proxy password.

Authentication for HTTPS Receiver

By default, LogicMonitor Data Publisher sends data in the noAuth mode. You can authenticate using bearer token or follow the basic authentication method. To enable the Auth mode, perform the following steps:

  1. In LogicMonitor, navigate to Settings > Collectors.
  2. Under the Collectors tab, select the Collector that you want to configure.  
  3. Select More option More and then select Collector Configuration.
  4. In the agent.conf settings, set value for the following properties:
    • To enable authentication, set value for agent.publisher.enable.auth.
    • To authenticate using the bearer token, set value for publisher.http.bearer.token.
    • To authenticate using basic authentication, set value for publisher.http.auth.user and publisher.http.auth.password.
  5. Restart the Collector.
    LogicMonitor Data Publisher switches to the Auth mode. 

Dependencies on HTTPS Receiver Request Headers

The HTTPS Publisher sends data over an HTTPS endpoint with the following https client request headers:

KeyValueHeader Type
Content-Typeapplication/jsonDefault
Content-EncodingGZIPDefault
Accept-Encodinggzip,deflateDefault
AuthorizationBasic  <username:password>
OR
Bearer <Encrypted-Token>
WITHAUTH, if authentication (agent.publisher.enable.auth) is enabled.

LogicMonitor Data Publisher Collection and Conversion for HTTPS Receiver

LMDP collects the metrics and add metadata details which is converted into an OTLP-formatted JSON string.

HTTPS Receiver Data Model

LogicMonitor Data Publisher converts metrics data into an OTLP-formatted JSON string. OTLP is a standard protocol for transmitting telemetry data in observability and monitoring systems. The OTLP converter is a gRPC service in LogicMonitor Data Publisher that implements protobuf (based on metrics.protoversion 1.0.0) to convert Collector metrics data into an OTLP-formatted JSON string. Metrics data in OTLP consists of one or more time series, where each time series represents a set of related datapoints over time.

The following is an example of OTLP-formatted metrics data in JSON format for LogicMonitor_Collector_ThreadCPUUsage datasource of netscan-propsdetection instance.

{
    "resourceMetrics": [
        {
            "resource": {
                "attributes": [
                    {
                        "key": "hostName",
                        "value": {
                            "stringValue": "127.0.0.1"
                        }
                    },
                    {
                        "key": "hostId",
                        "value": {
                            "stringValue": "1017594"
                        }
                    },
                    {
                        "key": "devicePropKey",
                        "value": {
                            "stringValue": "devicePropValue"
                        }
                    }
                ]
            },
            "scopeMetrics": [
                {
                    "scope": {
                        "name": "LogicMonitor_Collector_ThreadCPUUsage",
                        "attributes": [
                            {
                                "key": "collector",
                                "value": {
                                    "stringValue": "jmx"
                                }
                            },
                            {
                                "key": "epoch",
                                "value": {
                                    "stringValue": "1715263558360"
                                }
                            },
                            {
                                "key": "datasourceId",
                                "value": {
                                    "stringValue": "128265135"
                                }
                            },
                            {
                                "key": "datasourceInstanceId",
                                "value": {
                                    "stringValue": "367542931"
                                }
                            }
                        ]
                    },
                    "metrics": [
                        {
                            "name": "CpuUsage",
                            "sum": {
                                "dataPoints": [
                                    {
                                        "startTimeUnixNano": "1715263558360000000",
                                        "timeUnixNano": "1715263558360000000",
                                        "asDouble": 0,
                                        "attributes": [
                                            {
                                                "key": "dataSourceInstanceName",
                                                "value": {
                                                    "stringValue": "LogicMonitor_Collector_ThreadCPUUsage-netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "datapointid",
                                                "value": {
                                                    "stringValue": "197642"
                                                }
                                            },
                                            {
                                                "key": "wildValue",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "wildAlias",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            }
                                        ]
                                    }
                                ],
                                "aggregationTemporality": "AGGREGATION_TEMPORALITY_DELTA",
                                "isMonotonic": true
                            }
                        },
                        {
                            "name": "ProcessorCount",
                            "gauge": {
                                "dataPoints": [
                                    {
                                        "startTimeUnixNano": "1715263558360000000",
                                        "timeUnixNano": "1715263558360000000",
                                        "asDouble": 10,
                                        "attributes": [
                                            {
                                                "key": "dataSourceInstanceName",
                                                "value": {
                                                    "stringValue": "LogicMonitor_Collector_ThreadCPUUsage-netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "datapointid",
                                                "value": {
                                                    "stringValue": "197643"
                                                }
                                            },
                                            {
                                                "key": "wildValue",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "wildAlias",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            }
                                        ]
                                    }
                                ]
                            }
                        },
                        {
                            "name": "RunnableThreadCnt",
                            "gauge": {
                                "dataPoints": [
                                    {
                                        "startTimeUnixNano": "1715263558360000000",
                                        "timeUnixNano": "1715263558360000000",
                                        "asDouble": 0,
                                        "attributes": [
                                            {
                                                "key": "dataSourceInstanceName",
                                                "value": {
                                                    "stringValue": "LogicMonitor_Collector_ThreadCPUUsage-netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "datapointid",
                                                "value": {
                                                    "stringValue": "197644"
                                                }
                                            },
                                            {
                                                "key": "wildValue",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "wildAlias",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            }
                                        ]
                                    }
                                ]
                            }
                        },
                        {
                            "name": "ThreadCnt",
                            "gauge": {
                                "dataPoints": [
                                    {
                                        "startTimeUnixNano": "1715263558360000000",
                                        "timeUnixNano": "1715263558360000000",
                                        "asDouble": 0,
                                        "attributes": [
                                            {
                                                "key": "dataSourceInstanceName",
                                                "value": {
                                                    "stringValue": "LogicMonitor_Collector_ThreadCPUUsage-netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "datapointid",
                                                "value": {
                                                    "stringValue": "197645"
                                                }
                                            },
                                            {
                                                "key": "wildValue",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            },
                                            {
                                                "key": "wildAlias",
                                                "value": {
                                                    "stringValue": "netscan-propsdetection"
                                                }
                                            }
                                        ]
                                    }
                                ]
                            }
                        }
                    ]
                }
            ]
        }
    ]
}

The resourceMetrics consists of the following:

  • ResourceMetrics—JSON array of one or more resources. It depends on the publisher.dequeue.count property.
  • Resource—The metadata of the device from which the metrics is collected.
  • ScopeMetrics
    • Scope—The metadata of the datasource for which metrics is collected.
    • Metrics—Actual datapoints of the datasource which are retrieved from the device.

Note: Raw data has two types of datapoints: normal and complex. LogicMonitor Data Publisher can only send normal datapoints in metrics data.

HTTPS Receiver Metadata Details

The OTLP-formatted JSON string contains data collected for a single poll along with the following metadata: 

  • Host name or Device name 
  • DataSource name
  • Instance name 
  • Polling interval
  • Epoch details
  • DataPoint name

HTTPS Receiver

The LogicMonitor Data Publisher sends data in OTLP-formatted JSON string. The HTTPS receiver must be able to read and convert metrics data using the metrics.proto. For more information, see metrics.proto GitHub documentation. 

LogicMonitor Data Publisher for HTTPS Receiver Performance Monitoring

LogicMonitor Data Publisher datasource monitors and provides real-time performance metrics and tracks the following datapoints: 

DatapointDescription
CountOfDataEnqueuedCount of data enqueued to bigqueue.
CountOfDataDequeuedCount of data dequeued from bigqueue.
SizeOfBigQueueSize of the queue in which data persists.
HTTPRequestCountNumber of requests to the HTTPS endpoint.
HttpRedirectsCountNumber of redirect requests.
SuccessfulHTTPRedirectsCountNumber of successful redirect requests.
FailedHTTPRedirectsCountNumber of failed redirect requests.
SuccessfulRequestsToHTTPEndpointNumber of successful requests to the HTTPS endpoint.
CountofRequestsfailedDueToAuthErrorNumber of requests failed due to authentication errors.
CountofRequestsfailedDueToNetworkErrorNumber of requests failed due to network errors.
TimeTakenforDequeueAndConversionTime taken for dequeing data from queue and converting them to OTLP-formatted JSON string.
SizeOfDataPublishedinBytesSize (in bytes) of data published to HTTPS endpoint.

Note: If the connection with HTTPS endpoint fails, LogicMonitor Data Publisher can store data for 30 minutes.