1. SendingDS.py renamed to Sending.py

2. ReceivingDS.py renamed to ElementLogger.py
3. Introduced CentralLogger.py
4. Three Log levels introduced for 3 targets - Storage, Element and Central
5. Levels settable via commands in ElementLogger.
6. Filtration logic currently at ElementLogger and CentralLogger (refer TBD/TBC section - point 1)

TBD/TBC
1. Log message filteration at Sending.py to be considered. No way to specify TANGO log targets. self.xxx_stream goes to all configured targets.
2. Need / Interpretation of attributes StorageLoggingLevel, ElementLoggingLevel and CentralLoggingLevel.
3. SetxxxLevel Commands between ElementLogger.py and CentralLogger.py to be worked out.

sandbox/logging/CentralLogger.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""CentralLogger device server receiving logs from SendingDS server"""
+import sys
+import time
+import logging
+from PyTango import server, DeviceProxy, Database, DbDevInfo, DevState, DebugIt, AttrQuality, AttrWriteType, DispLevel 
+from PyTango.server import Device, DeviceMeta, attribute, command, run, device_property
+
+
+"""CentralLogger device server class"""
+class CentralLogger(Device):
+    __metaclass__ = DeviceMeta
+
+    def init_device(self):
+        Device.init_device(self)
+        self.set_state(DevState.STANDBY)
+        self.info_stream("Init CentralLogger Device.")
+
+    @command(dtype_in='DevVarLongStringArray', dtype_out=None)
+    def SetCentralLoggingLevel(self, element_devices_and_levels):
+        CentralLoggingLevel = element_devices_and_levels[0][:]
+        CentralLoggingDevice = element_devices_and_levels[1][:]
+        i = 0
+        while i < len(CentralLoggingLevel[:]):
+            self.info_stream("%s,%s", CentralLoggingLevel[i], CentralLoggingDevice[i])
+            dev1 = DeviceProxy(CentralLoggingDevice[i])
+            dev1.centralLoggingLevel = CentralLoggingLevel[i]
+            property_names = ["logging_level",
+                              "logging_target",
+                             ]
+            dev_properties = dev1.get_property(property_names)
+            dev_properties["logging_level"] = ["DEBUG"]
+            dev_properties["logging_target"].append("device::central/cdev/cdev1")
+            dev1.put_property(dev_properties)
+            dev1.add_logging_target("device::central/cdev/cdev1")
+            i+=1
+
+    """Logs are received from all element devices at all levels.
+       Filteration happens within the log function depending upon
+       CentralLoggingLevel of each element device.
+       NOTE : This fiteration logic is still under consideration."""
+    @command(dtype_in='DevVarStringArray', dtype_out=None)
+    def log(self, details):
+	cmessage = details[3]
+        clevel = details[1]
+        tango_log_level = {"FATAL":1,"ERROR":2,"WARN":3,"INFO":4,"DEBUG":5}
+        level_number = tango_log_level[clevel]
+        clogsource = details[2]
+        if clogsource == details[2]:
+            device = DeviceProxy(clogsource)
+            deviceLogLevel = device.centralLoggingLevel
+
+            if clevel == "FATAL" and level_number <= deviceLogLevel:
+                self.fatal_stream("%s : %s",clogsource, cmessage)
+            elif clevel == "ERROR" and level_number <= deviceLogLevel:
+                self.error_stream("%s : %s",clogsource, cmessage)
+            elif clevel == "WARN" and level_number <= deviceLogLevel:
+                self.warn_stream("%s : %s",clogsource, cmessage)
+            elif clevel == "INFO" and level_number <= deviceLogLevel:
+                self.info_stream("%s : %s",clogsource, cmessage)
+            elif clevel == "DEBUG" and level_number <= deviceLogLevel:
+                self.debug_stream("%s : %s",clogsource, cmessage)
+            else:
+                pass
+        else:
+            pass
+
+run((CentralLogger,))

sandbox/logging/ElementLogger.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""ElementLogger device server receiving logs from another device server"""
+import sys
+import time
+import logging
+from PyTango import server, DeviceProxy, Database, DbDevInfo, DevState, DebugIt, AttrQuality, AttrWriteType, DispLevel 
+from PyTango.server import Device, DeviceMeta, attribute, command, run, device_property
+
+
+"""ElementLogger device server class"""
+class ElementLogger(Device):
+    __metaclass__ = DeviceMeta
+
+    def init_device(self):
+        Device.init_device(self)
+        self.__StorageLoggingLevel = 5 #Storage logging level for ElementLogger(Unused currently)
+        self.__ElementLoggingLevel = 5 #Element logging level for all Element devices(Unused currently)
+        self.set_state(DevState.STANDBY)
+        self.info_stream("Init ElementLogger Device.")
+
+    @command(dtype_in='DevVarLongStringArray', dtype_out=None)
+    def SetStorageLoggingLevel(self, storages):
+        StorageLoggingLevel = storages[0][:]
+        StorageLoggingDevice = storages[1][:]
+        i = 0
+        while i < len(StorageLoggingLevel[:]):
+            self.info_stream("%s,%s", StorageLoggingLevel[i], StorageLoggingDevice[i])
+            dev1 = DeviceProxy(StorageLoggingDevice[i])
+            dev1.storageLoggingLevel = StorageLoggingLevel[i]
+            i+=1
+
+    @command(dtype_in='DevVarLongStringArray', dtype_out=None)
+    def SetElementLoggingLevel(self, element_devices_and_levels):
+        ElementLoggingLevel = element_devices_and_levels[0][:]
+        ElementLoggingDevice = element_devices_and_levels[1][:]
+        i = 0
+        while i < len(ElementLoggingLevel[:]):
+            self.info_stream("%s,%s", ElementLoggingLevel[i], ElementLoggingDevice[i])
+            dev1 = DeviceProxy(ElementLoggingDevice[i])
+            dev1.elementLoggingLevel = ElementLoggingLevel[i]
+            property_names = ["logging_level",
+                              "logging_target",
+                             ]
+            dev_properties = dev1.get_property(property_names)
+            dev_properties["logging_level"] = ["DEBUG"]
+            dev_properties["logging_target"].append("device::ellogger/elem/elem1")
+            dev1.put_property(dev_properties)
+            dev1.add_logging_target("device::ellogger/elem/elem1")
+            i+=1
+        
+    """Logs are received from all element devices at all levels.
+       Filteration happens within the log function depending upon
+       ElementLoggingLevel of each element device.
+       NOTE : This fiteration logic is still under consideration."""
+    @command(dtype_in='DevVarStringArray', dtype_out=None)
+    def log(self, details):
+	message = details[3]
+        level = details[1]
+        tango_log_level = {"FATAL":1,"ERROR":2,"WARN":3,"INFO":4,"DEBUG":5}
+        level_number = tango_log_level[level]
+        logsource = details[2]
+        if logsource == details[2]:
+            device = DeviceProxy(logsource)
+            deviceLogLevel = device.elementLoggingLevel
+            if level == "FATAL" and level_number <= deviceLogLevel:
+                self.fatal_stream("%s : %s",logsource, message)
+            elif level == "ERROR" and level_number <= deviceLogLevel:
+                self.error_stream("%s : %s",logsource, message)
+            elif level == "WARN" and level_number <= deviceLogLevel:
+                self.warn_stream("%s : %s",logsource, message)
+            elif level == "INFO" and level_number <= deviceLogLevel:
+                self.info_stream("%s : %s",logsource, message)
+            elif level == "DEBUG" and level_number <= deviceLogLevel: 
+                self.debug_stream("%s : %s",logsource, message)
+            else:
+                pass
+        else:
+            pass
+
+run((ElementLogger,))

sandbox/logging/Sending.py

+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""Sending Device server which is logged by ElementLogger and CentralLogger"""
+import sys
+import time
+import logging
+import logging.handlers
+import syslog
+from logging.handlers import SysLogHandler
+from PyTango import AttrQuality, AttrWriteType, DispLevel, DevState, DebugIt, Database, DbDevInfo, DeviceProxy
+from PyTango.server import Device, DeviceMeta, attribute, command, run, device_property
+
+logger = logging.getLogger("Sending")
+syslog = SysLogHandler(address='/dev/log', facility='user')
+formatter = logging.Formatter('%(name)s: %(levelname)s %(module)s %(message)r')
+syslog.setFormatter(formatter)
+logger.addHandler(syslog)
+
+"""Sending Device server class"""
+class Sending(Device):
+    __metaclass__ = DeviceMeta
+
+    """Attributes for setting logging levels for element storage and central"""
+    elementLoggingLevel = attribute(label="ElementLogginglevel", dtype=int,
+                         fget="get_elementLoggingLevel",
+                         fset="set_elementLoggingLevel",
+                         doc="Sets element logging level")
+
+    storageLoggingLevel = attribute(label="StorgeLoggingLevel", dtype=int,
+                         fget="get_storageLoggingLevel",
+                         fset="set_storageLoggingLevel",
+                         doc="Sets syslog logging level")
+
+    centralLoggingLevel = attribute(label="CentralLoggingLevel", dtype=int,
+                         fget="get_centralLoggingLevel",
+                         fset="set_centralLoggingLevel",
+                         doc="Sets Central logging level")
+
+    def init_device(self):
+        Device.init_device(self)
+        self.set_state(DevState.STANDBY)
+        self.__elementLoggingLevel = 5        
+        self.__storageLoggingLevel = 5        
+        self.__centralLoggingLevel = 5        
+        logger.setLevel(logging.DEBUG)
+
+    def get_elementLoggingLevel(self):
+        return self.__elementLoggingLevel
+
+    def set_elementLoggingLevel(self, elementLoggingLevel):
+        self.__elementLoggingLevel = elementLoggingLevel
+        return elementLoggingLevel
+
+    def get_centralLoggingLevel(self):
+        return self.__centralLoggingLevel
+
+    def set_centralLoggingLevel(self, centralLoggingLevel):
+        self.__centralLoggingLevel = centralLoggingLevel
+        return centralLoggingLevel
+
+    def get_storageLoggingLevel(self):
+        return self.__storageLoggingLevel
+
+    def set_storageLoggingLevel(self, storageLoggingLevel):
+        self.debug_stream("In set_StorageLogginglevel")
+        self.__storageLoggingLevel = storageLoggingLevel
+
+        if self.__storageLoggingLevel == 1:
+            logger.setLevel(logging.FATAL)
+        elif self.__storageLoggingLevel == 2:
+            logger.setLevel(logging.ERROR)
+        elif self.__storageLoggingLevel == 3:
+            logger.setLevel(logging.WARNING)
+        elif self.__storageLoggingLevel == 4:
+            logger.setLevel(logging.INFO)
+        elif self.__storageLoggingLevel == 5:
+            logger.setLevel(logging.DEBUG)
+        else:
+            logger.setLevel(logging.DEBUG)
+        return storageLoggingLevel
+
+    @command
+    def TurnOn(self):
+        # turn on the sending device.
+        self.set_state(DevState.ON)
+        self.debug_stream("TurnOn Sending DEBUG")
+        self.info_stream("TurnOn Sending INFO")
+        self.warn_stream("TurnOn Sending WARNING")
+        self.error_stream("TurnOn Sending ERROR")
+        self.fatal_stream("TurnOn Sending FATAL")
+
+        logger.debug("TurnOn Sending debug")
+        logger.info("TurnOn Sending info")
+        logger.warning("TurnOn Sending warn")
+        logger.error("TurnOn Sending error")
+        logger.fatal("TurnOn Sending fatal")
+
+    @command
+    def TurnOff(self):
+        # turn off the sending device
+        self.set_state(DevState.OFF)
+        self.debug_stream("TurnOff Sending DEBUG")
+        self.info_stream("TurnOff Sending INFO")
+        self.warn_stream("TurnOff Sending WARNING")
+        self.error_stream("TurnOff Sending ERROR")
+        self.fatal_stream("TurnOff Sending FATAL")
+
+        logger.debug("TurnOff Sending debug")
+        logger.info("TurnOff Sending info")
+        logger.warning("TurnOff Sending warn")
+        logger.error("TurnOff Sending error")
+        logger.fatal("TurnOff Sending fatal")
+
+run([Sending])