Examples - Instrumentation - OPC UA event logging

.NET

// This example demonstrates the loggable entries originating in the OPC-UA client engine and the EasyUAClient component.

using System;
using OpcLabs.BaseLib.Instrumentation;
using OpcLabs.EasyOpc.UA;
using OpcLabs.EasyOpc.UA.OperationModel;

namespace UADocExamples._EasyUAClient
{
    class LogEntry
    {
        public static void Main1()
        {
            UAEndpointDescriptor endpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer";
            // or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            // or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            // Hook static events
            EasyUAClient.LogEntry += EasyUAClientOnLogEntry;

            try
            {
                // Do something - invoke an OPC read, to trigger some loggable entries.
                var client = new EasyUAClient();
                try
                {
                    client.ReadValue(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10853");
                }
                catch (UAException uaException)
                {
                    Console.WriteLine("*** Failure: {0}", uaException.GetBaseException().Message);
                    return;
                }

                Console.WriteLine("Processing log entry events for 1 minute...");
                System.Threading.Thread.Sleep(60 * 1000);

                Console.WriteLine("Finished.");
            }
            finally
            {
                // Unhook static events
                EasyUAClient.LogEntry -= EasyUAClientOnLogEntry;
            }
        }

        // Event handler for the LogEntry event. It simply prints out the event.
        private static void EasyUAClientOnLogEntry(object sender, LogEntryEventArgs logEntryEventArgs)
        {
            Console.WriteLine(logEntryEventArgs);
        }
    }
}

# This example demonstrates the loggable entries originating in the OPC-UA client engine and the EasyUAClient component.

# The QuickOPC package is needed. Install it using "pip install opclabs_quickopc".
import opclabs_quickopc
import time

# Import .NET namespaces.
from OpcLabs.EasyOpc.UA import *
from OpcLabs.EasyOpc.UA.OperationModel import *


# Event handler for the LogEntry event. It simply prints out the event.
def onLogEntry(sender, logEntryEventArgs):
    print(logEntryEventArgs)


endpointDescriptor = UAEndpointDescriptor('opc.tcp://opcua.demo-this.com:51210/UA/SampleServer')
# or 'http://opcua.demo-this.com:51211/UA/SampleServer' (currently not supported)
# or 'https://opcua.demo-this.com:51212/UA/SampleServer/'

# Hook static events.
EasyUAClient.LogEntry += onLogEntry

# Instantiate the client object.
client = EasyUAClient()

# Do something - invoke an OPC read, to trigger some loggable entries.
try:
    value = IEasyUAClientExtension.ReadValue(client,
                                             endpointDescriptor,
                                             UANodeDescriptor('nsu=http://test.org/UA/Data/ ;i=10853'))
except UAException as uaException:
    print('*** Failure: ' + uaException.GetBaseException().Message)
    exit()

print('Processing log entry events for 1 minute...')
time.sleep(60)

print()
print('Finished.')

' This example demonstrates the loggable entries originating in the OPC-UA client engine and the EasyUAClient component.

Imports OpcLabs.BaseLib.Instrumentation
Imports OpcLabs.EasyOpc.UA
Imports OpcLabs.EasyOpc.UA.OperationModel

Namespace _EasyUAClient
    Friend Class LogEntry
        Public Shared Sub Main1()

            Dim endpointDescriptor As UAEndpointDescriptor =
                "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer"
            ' or "http://opcua.demo-this.com:51211/UA/SampleServer" (currently not supported)
            ' or "https://opcua.demo-this.com:51212/UA/SampleServer/"

            ' Hook static events
            AddHandler EasyUAClient.LogEntry, AddressOf EasyUAClientOnLogEntry

            Try
                ' Do something - invoke an OPC read, to trigger some loggable entries.
                Dim client = New EasyUAClient()
                Try
                    client.ReadValue(endpointDescriptor, "nsu=http://test.org/UA/Data/ ;i=10853")
                Catch uaException As UAException
                    Console.WriteLine("*** Failure: {0}", uaException.GetBaseException.Message)
                    Exit Sub
                End Try

                Console.WriteLine("Processing log entry events for 1 minute...")
                Threading.Thread.Sleep(60 * 1000)

                Console.WriteLine("Finished.")
            Finally
                ' Unhook static events
                RemoveHandler EasyUAClient.LogEntry, AddressOf EasyUAClientOnLogEntry
            End Try

        End Sub


        ' Event handler for the LogEntry event. It simply prints out the event.
        Private Shared Sub EasyUAClientOnLogEntry(ByVal sender As Object, ByVal logEntryEventArgs As LogEntryEventArgs)
            Console.WriteLine(logEntryEventArgs)
        End Sub
    End Class
End Namespace

COM

// This example demonstrates the loggable entries originating in the OPC-UA client engine and the EasyUAClient component.

#include "stdafx.h"    // Includes "QuickOpc.h", and other commonly used files
#include <atlcom.h>
#include "LogEntry.h"

namespace _EasyUAClientManagement
{
    // CEasyUAClientManagementEvents

    class CEasyUAClientManagementEvents : public IDispEventImpl<1, CEasyUAClientManagementEvents>
    {
    public:
    BEGIN_SINK_MAP(CEasyUAClientManagementEvents)
        // Event handlers must have the __stdcall calling convention
        SINK_ENTRY(1, 1 /*DISPID_EASYUACLIENTManagementEVENTS_LOGENTRY*/, &CEasyUAClientManagementEvents::LogEntry)
    END_SINK_MAP()

    public:
        // Event handler for the LogEntry event. It simply prints out the event.
        STDMETHOD(LogEntry)(VARIANT varSender, _LogEntryEventArgs* pEventArgs)
        {
            _tprintf(_T("%s\n"), (LPCTSTR)CW2CT(pEventArgs->ToString));
            return S_OK;
        }
    };



    void LogEntry::Main()
    {
        // Initialize the COM library
        CoInitializeEx(NULL, COINIT_MULTITHREADED);
        {
            // The management object allows access to static behavior - here, the shared LogEntry event.
            _EasyUAClientManagementPtr ClientManagementPtr(__uuidof(EasyUAClientManagement));

            // Hook events
            CEasyUAClientManagementEvents* pClientManagementEvents = new CEasyUAClientManagementEvents();
            AtlGetObjectSourceInterface(ClientManagementPtr, &pClientManagementEvents->m_libid, 
                &pClientManagementEvents->m_iid, 
                &pClientManagementEvents->m_wMajorVerNum, &pClientManagementEvents->m_wMinorVerNum);
            pClientManagementEvents->m_iid = _uuidof(DEasyUAClientManagementEvents);
            pClientManagementEvents->DispEventAdvise(ClientManagementPtr, &pClientManagementEvents->m_iid);

            // Do something - invoke an OPC read, to trigger some loggable entries.
            _EasyUAClientPtr ClientPtr(__uuidof(EasyUAClient));
            ClientPtr->ReadValue(
                //L"http://opcua.demo-this.com:51211/UA/SampleServer", 
                L"opc.tcp://opcua.demo-this.com:51210/UA/SampleServer",
                L"nsu=http://test.org/UA/Data/ ;i=10853");

            _tprintf(_T("Processing log entry events for 1 minute...\n"));
            Sleep(60*1000);

            // Unhook events
            pClientManagementEvents->DispEventUnadvise(ClientManagementPtr, &pClientManagementEvents->m_iid);
        }
         // Release all interface pointers BEFORE calling CoUninitialize()
        CoUninitialize();
    }
}

// This example demonstrates the loggable entries originating in the OPC-UA
// client engine and the EasyUAClient component.

type
  TClientManagementEventHandlers = class
    procedure OnLogEntry(
      Sender: TObject;
      sender0: OleVariant;
      eventArgs: _LogEntryEventArgs);
  end;

// Event handler for the LogEntry event. It simply prints out the event.
procedure TClientManagementEventHandlers.OnLogEntry(
  Sender: TObject;
  sender0: OleVariant;
  eventArgs: _LogEntryEventArgs);
begin
    WriteLn(eventArgs.ToString);
end;

class procedure LogEntry.Main;
var
  Client: EasyUAClient;
  EvsClientManagement: TEvsEasyUAClientManagement;
  ClientManagement: EasyUAClientManagement;
  ClientManagementEventHandlers: TClientManagementEventHandlers;
  Value: OleVariant;
begin
  // The Management object allows access to static behavior - here, the
  // shared LogEntry event.
  EvsClientManagement := TEvsEasyUAClientManagement.Create(nil);
  ClientManagement := EvsClientManagement.ComServer;
  ClientManagementEventHandlers := TClientManagementEventHandlers.Create;
  EvsClientManagement.OnLogEntry := @ClientManagementEventHandlers.OnLogEntry;

  // Do something - invoke an OPC read, to trigger some loggable entries.
  Client := CoEasyUAClient.Create;
  Value := Client.ReadValue(
    //'http://opcua.demo-this.com:51211/UA/SampleServer',
    'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer',
    'nsu=http://test.org/UA/Data/ ;i=10853');

  WriteLn('Processing log entry events for 1 minute...');
  PumpSleep(60*1000);
end;

// This example demonstrates the loggable entries originating in the OPC-UA
// client engine and the EasyUAClient component.

type
  TClientManagementEventHandlers130 = class
    procedure OnLogEntry(
      ASender: TObject;
      sender: OleVariant;
      const eventArgs: _LogEntryEventArgs);
  end;

// Event handler for the LogEntry event. It simply prints out the event.
procedure TClientManagementEventHandlers130.OnLogEntry(
  ASender: TObject;
  sender: OleVariant;
  const eventArgs: _LogEntryEventArgs);
begin
    WriteLn(eventArgs.ToString);
end;

class procedure LogEntry.Main;
var
  Client: OpcLabs_EasyOpcUA_TLB._EasyUAClient;
  ClientManagement: TEasyUAClientManagement;
  ClientManagementEventHandlers: TClientManagementEventHandlers130;
  Value: OleVariant;
begin
  // The management object allows access to static behavior - here, the
  // shared LogEntry event.
  ClientManagement := TEasyUAClientManagement.Create(nil);
  ClientManagementEventHandlers := TClientManagementEventHandlers130.Create;
  ClientManagement.OnLogEntry := ClientManagementEventHandlers.OnLogEntry;
  ClientManagement.Connect;

  // Do something - invoke an OPC read, to trigger some loggable entries.
  Client := CoEasyUAClient.Create;
  try
    Value := Client.ReadValue(
      //'http://opcua.demo-this.com:51211/UA/SampleServer',
      //'https://opcua.demo-this.com:51212/UA/SampleServer/',
      'opc.tcp://opcua.demo-this.com:51210/UA/SampleServer',
      'nsu=http://test.org/UA/Data/ ;i=10853');
  except
    on E: EOleException do
    begin
      WriteLn(Format('*** Failure: %s', [E.GetBaseException.Message]));
      //Exit;
    end;
  end;

  WriteLn('Processing log entry events for 1 minute...');
  PumpSleep(60*1000);

  WriteLn('Finished.');
  FreeAndNil(ClientManagement);
  FreeAndNil(ClientManagementEventHandlers);
end;

// This example demonstrates the loggable entries originating in the OPC-UA client engine and the EasyUAClient component.

class ClientManagementEvents {
    // Event handler for the LogEntry event. It simply prints out the event.
    function LogEntry($Sender, $E)
    {
    printf("%s\n", $E);
    }
}



// The management object allows access to static behavior - here, the shared LogEntry event.
$ClientManagement = new COM("OpcLabs.EasyOpc.UA.EasyUAClientManagement");
$ClientManagementEvents = new ClientManagementEvents();
com_event_sink($ClientManagement, $ClientManagementEvents, "DEasyUAClientManagementEvents");

// Do something - invoke an OPC read, to trigger some loggable entries.
$Client = new COM("OpcLabs.EasyOpc.UA.EasyUAClient");
try
{
    $value = $Client->ReadValue(
        //"http://opcua.demo-this.com:51211/UA/SampleServer", 
        "opc.tcp://opcua.demo-this.com:51210/UA/SampleServer", 
        "nsu=http://test.org/UA/Data/ ;i=10853");
}
catch (com_exception $e)
{
    printf("*** Failure: %s\n", $e->getMessage());
    Exit();
}


printf("Processing log entry events for 1 minute...");
$startTime = time(); do { com_message_pump(1000); } while (time() < $startTime + 60);

Rem This example demonstrates the loggable entries originating in the OPC-UA client engine and the EasyUAClient component.

' The management object allows access to static behavior - here, the shared LogEntry event.
'Public WithEvents ClientManagement1 As EasyUAClientManagement

Private Sub LogEntry_Main_Command_Click()
    OutputText = ""
    
    Set ClientManagement1 = New EasyUAClientManagement
    
    ' Do something - invoke an OPC read, to trigger some loggable entries.
    Dim client As New EasyUAClient
    On Error Resume Next
    Dim value As Variant
    value = client.ReadValue("opc.tcp://opcua.demo-this.com:51210/UA/SampleServer", "nsu=http://test.org/UA/Data/ ;i=10853")
    If Err.Number <> 0 Then
        OutputText = OutputText & "*** Failure: " & Err.Source & ": " & Err.Description & vbCrLf
        Exit Sub
    End If
    On Error GoTo 0

    OutputText = OutputText & "Processing log entry events for 1 minute..." & vbCrLf
    Pause 60000
    
    Set ClientManagement1 = Nothing
    OutputText = OutputText & "Finished..." & vbCrLf
End Sub

' Event handler for the LogEntry event. It simply prints out the event.
Private Sub ClientManagement1_LogEntry(ByVal sender As Variant, ByVal eventArgs As OpcLabs_BaseLib.LogEntryEventArgs)
    OutputText = OutputText & eventArgs & vbCrLf
End Sub

Rem This example demonstrates the loggable entries originating in the OPC-UA client engine and the EasyUAClient component.

Option Explicit

' The management object allows access to static behavior - here, the shared LogEntry event.
Dim ClientManagement: Set ClientManagement = CreateObject("OpcLabs.EasyOpc.UA.EasyUAClientManagement")
WScript.ConnectObject ClientManagement, "ClientManagement_"

' Do something - invoke an OPC read, to trigger some loggable entries.
Dim Client: Set Client = CreateObject("OpcLabs.EasyOpc.UA.EasyUAClient")
On Error Resume Next
Dim value: value = Client.ReadValue("opc.tcp://opcua.demo-this.com:51210/UA/SampleServer", "nsu=http://test.org/UA/Data/ ;i=10853")
If Err.Number <> 0 Then
    WScript.Echo "*** Failure: " & Err.Source & ": " & Err.Description
    WScript.Quit
End If
On Error Goto 0

WScript.Echo "Processing log entry events for 1 minute..."
WScript.Sleep 60*1000



' Event handler for the LogEntry event. It simply prints out the event.
Sub ClientManagement_LogEntry(Sender, e)
    WScript.Echo e
End Sub

Conceptual

Component Event Logging