What is this?

This knowledgebase contains questions and answers about PRTG Network Monitor and network monitoring in general. You are invited to get involved by asking and answering questions!

Learn more

PRTG Network Monitor

Intuitive to Use. Easy to manage.
300.000 administrators have chosen PRTG to monitor their network. Find out how you can reduce cost, increase QoS and ease planning, as well.

Free Download

Top Tags


View all Tags

Channel data via API

Votes:

0

Your Vote:

Up

Down

Channel data seems to be reported via the Rest API (sometimes) via exponential notation like this: -000000000000062-0.1000. Most programming languages expect something like -000000000000062E-0.1000 or even better -62E-0.1. I'm using C# w/ JSON.NET serialization.

Tried changing the channel data to 2 decimal points in settings but no effect on query via API, I imagine that just affects the graph representation.

Is there any way to control this? I'm using content=sensors and content=channels calls, looking at the _RAW data.

Thanks

ps - the captcha is impossible and really is it necessary when one has logged in?

api channel exponential scientific-notation

Created on Aug 11, 2014 6:57:37 PM by  Lisa von Schlegell (40) 1



4 Replies

Votes:

0

Your Vote:

Up

Down

Dear Lisa

I am sorry, we need the captcha to prevent the KB being flooded by spam.

The data returned by the API has to be converted within your script. The API only provides the raw data without the option to set a numerical format.

Created on Aug 13, 2014 2:13:27 PM by  Arne Seifert [Paessler Support]



Votes:

0

Your Vote:

Up

Down

I've looked at this further - its apparently a formatting bug not an odd exponential notation. I think this : -000000000000062-0.1000 is meant to represent -62.1.

Could someone at PRTG confirm this and give me an actual characterization of the bug so that I know how to compensate for it? I'm seeing it only on raw channel data, not on the primary data for a sensor, but I don't know if that's a data-dependent coincidence.

Also, its unclear to me in what situations the divisor is or is not applied to raw data - both channel data and sensor primary data.

Lisa

Created on Aug 14, 2014 8:08:36 PM by  Lisa von Schlegell (40) 1



Votes:

0

Your Vote:

Up

Down

Dear Lisa

Please send the API call you use and the output file you get to [email protected] so that we can inspect what exactly is going on.

Created on Aug 15, 2014 12:01:43 PM by  Arne Seifert [Paessler Support]



Votes:

4

Your Vote:

Up

Down

Paessler support has answered this question for me. Here's response in case it helps someone else: " The data format you see is an internal format. For some sensors, PRTG automatically converts the internal format to a readable one.

In the case when this internal format is not converted but shown as-is, for example "-000000000000031-0.1000" please manually cut the "-0." part out and replace it with a point. For nonnegative numbers, like "0000000000000000.0000", cut "0." out and replace it with a decimal point as well. "

I'm using JSON.NET serialization on a WCF REST service API, so my workaround is to apply this converter to the sensor channel raw data property. NOTE - my channel data is negative, so if you use this solution please double-check the positive data translation.

    /// <summary>
    /// Sensor channel data from request : 
    /// </summary>
    [DataContract]
    public class SensorChannelData
    {
        [DataMember(Name = "channels")]
        public ChannelData[] ChannelData { get; private set; }
    }

    [DataContract]
    public class ChannelData
    {
        [DataMember(Name = "name")]
        public ChannelType ChannelType { get; private set; }
        [DataMember(Name = "lastvalue")]
        public string DataString { get; private set; }
        [DataMember(Name = "lastvalue_raw")]
        [JsonConverter(typeof(PrtgRawDataJsonConverter))]
        public decimal ? Data { get; private set; }
    }

    /// <summary>
    /// PRTG raw data has an occasional formatting problem in channel raw data.
    /// This converter detects and modifies to a standard format
    /// </summary>
    /// <remarks>Annotate any PRTG channel raw data value property with this converter.</remarks>
    internal class PrtgRawDataJsonConverter :JsonConverter
    {
        private static readonly Regex NegativeMatch = new Regex(@"-(?:0|[1-9]\d*)(-0\.\d+)");
        private static readonly Regex PositiveMatch = new Regex(@"(0\d*)(0\.\d+)");
        /// <summary>
        /// Default implementation
        /// </summary>
        /// <param name="writer"></param>
        /// <param name="value"></param>
        /// <param name="serializer"></param>
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            serializer.Serialize(writer, value);
        }

        /// <summary>
        /// Deserialize property value from PRTG formatted number string.
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="objectType"></param>
        /// <param name="existingValue"></param>
        /// <param name="serializer"></param>
        /// <returns></returns>
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            if (reader.TokenType == JsonToken.None) return null;

            if (reader.TokenType == JsonToken.None) return null;
            var x = reader.Value as string;
            if (!string.IsNullOrEmpty(x))
            {
                // match number format like -00000000000000014-0.5 which translates apparently to -14.5
                if (NegativeMatch.IsMatch(x))
                {
                    x = x.Remove(x.LastIndexOf("-0.", StringComparison.InvariantCultureIgnoreCase), 2);
                }
                // match number format like 000000000000000140.5 which translates apparently to 14.5
                else if (PositiveMatch.IsMatch(x))
                {
                    x = x.Remove(x.LastIndexOf("0.", StringComparison.InvariantCultureIgnoreCase), 1);
                }
                try
                {
                    return JsonConvert.DeserializeObject(x, objectType);
                }
                catch (Exception ex)
                {
                    ex.LogAsIgnored();
                }
                return null;
            }
            // default number parsing
            return serializer.Deserialize(reader, objectType);
        }

        /// <summary>
        /// Can convert any number ( value type assignable from int)
        /// </summary>
        /// <param name="objectType"></param>
        /// <returns></returns>
        public override bool CanConvert(Type objectType)
        {
            return objectType.IsValueType && objectType.IsAssignableFrom(typeof (int));
        }
    }

Created on Aug 18, 2014 5:14:38 PM by  Lisa von Schlegell (40) 1

Last change on Aug 18, 2014 5:26:03 PM by  Arne Seifert [Paessler Support]



Please log in or register to enter your reply.


Disclaimer: The information in the Paessler Knowledge Base comes without warranty of any kind. Use at your own risk. Before applying any instructions please exercise proper system administrator housekeeping. You must make sure that a proper backup of all your data is available.