Category: Partners

How ServiceNow’s ‘Virtual Agent’ can assist your organisation: Part 3

Blog, ServiceNowKelly Cooke

This blog entry is part of a four-part blog series on how ServiceNow’s Virtual Agent can assist your organisation.

Part 3: Operational Insight & Accuracy

Every day that a service desk is operational, it creates data, both useful and not so useful.

As time continues though it can become quite overwhelming and the data that was once useful can be poisoned with data that makes it less useful. People tend to have different opinions, differing working styles and language quirks that is amplified when there is staff turnover.

As a result, the data they create is only as insightful as its consistency when dealing with a large amount of it.

Accuracy

Data accuracy and data in general is one of the most common issues in any organisation.

This can be due to several reasons, but there are some ways that inaccurate data that gets in the system can be avoided. When entering data repeatedly, it can be mundane, boring and although not done purposely, accidents can be and will be made. Not only this, individuals will normally only enter the information they want to or need to, so some insights that would be useful to know or capture simply won’t be. In making that more and more information mandatory however, it may even cause more mistakes as it is more work that does not appear immediately valuable to the people who enter it.

These are just some of the things that could be alleviated in a few different ways if required.

Virtual agents can assist in doing this entry without error, without complaints and because it will just do the same thing over and over, the mistakes will occur when done manually should not occur. This makes the resulting data more accurate. It is not only that however, it is something as simple as if someone has been worked on and has been resolved without contact.

You can track this, and the record will close once the conversation has closed with the virtual agent. In day to day work, you may be working on something that has been resolved, but you then go to lunch and forget to close the record, causing SLAs to breach and information to be forgotten. Once again, another possible data point that is compromised.

As a result, the way we attempt to resolve requests without contact needs to evolve, as the added complexity in certain issues of today’s world are not answerable with the previous methods described.

Insights

Accurate data and information is all well and good, but what is the point if it does not offer any real insight in how to improve your processes and business? This is likely because a lot of the information that is commonly captured is done only for contractual reasons.

Agents are not focused on improving service, because trying to capture this information and making it meaningful is a long and drawn out process This is often simply because everyone thinks differently and may enter the same different information differently.

Having a virtual agent alongside the journey though can assist in making this information consistent and capturing more information along the process in a logical matter as standard. Let’s think about the example of a few employees who are having issues connecting to the VPN.

In the various calls that had been made regarding VPN issues this week, Sam, Roger and Cameron have all been resolving these in different ways, but it has all been down to the singular issue. Sam has been saying it is because people are using their wrong username to connect to the VPN. Roger has been saying that people are attempting to use their email address to use the VPN. Cameron has been saying that people are not using their windows login username to use the VPN. If you read this on face value, they all appear similar, but requires someone that understands the issue to understand it it is all related to the same key issue.

Let’s just say now that these phone calls have now become a virtual agent flow that Sam, Roger and Cameron have designed with their years of experience on the service desk. They have created a flow talking about common VPN connectivity issues and listing off possible solutions in a logical step by step and conditional manner. In this flow, they also asking after each troubleshooting step if it helped or not. As the next person who has VPN connectivity issues continues along the process, they too have an issue that relates to the above scenario.

Now the virtual agent is answering it and provides the solution and tracks that a misunderstanding in what username should be used as a login method is extremely common and easily reported against. This is the case as the wording is consistent now. As a result of this, Sam decides that before people even request VPN access, he would highlight what format the username should be. In the meantime, Roger and Cameron are looking at what other common support issues they can resolve through the virtual agent and now have a more complex skill set then they did before through this design and continual improvement process.

This issue went through a few steps to get to this point but now is being proactively resolved by Sam highlighting the username format. As a summary, these steps were:

1. Reactive resolution: Numerous people called the service desk talking about service desk issues and spoke to Cameron, Sam and Roger about VPN connectivity issues.
2. Contactless resolution: The service desk realized this coming up and spoke about it in their daily standup, so Cameron, Sam and Roger created a virtual agent troubleshooting flow, capturing when this issue has been resolved.
3. Proactive resolution: Sam notifies users before requesting VPN access they need to enter a specific username and no more support calls are raised, minus the few that do not read the necessary steps correctly.

As issues progress towards the proactive resolution stage, the NPS and CSAT scores of the service desk improves, as less and less people need to wait in a queue to have their issue resolved or wait until they are answered from an email. This scenario, although may seem as a best case and overly convenient for the sake of a blog entry, is surprisingly a common situation that people find themselves in and can be brought across different less conveniently written scenarios. Even if the proactive resolution stage does not occur and the contactless resolution only occurs in half the scenarios, it is still a net improvement of never attempting to solve the issue. Out of the box, ServiceNow’s virtual agent can hook into its powerful survey application, so understanding what the service experience is easy to gauge as the weeks continue.

 

In the long run however, that should be a focus for the organisation as virtual agent assists in improving the service experience and as it should be highlighted, this matters.

In the fourth and final part of this four-part blog series, we will discuss just that, how service experience matters.

In the meantime, check out this great Virtual Agent demo from ServiceNow.

How ServiceNow’s ‘Virtual Agent’ can assist your organisation: Part 2

Blog, ServiceNowKelly Cooke

This blog entry is part of a four-part blog series on how ServiceNow’s Virtual Agent can assist your organisation.

Part 2: Contactless Resolution

Contactless resolution, no contact resolution and zero contact resolution are three ideas that are similar in concept, but are all trying to get essentially the same result.

This concept is not new at all, despite it getting more recent attention. Searching for zero contact resolution in my search engine, brings up a link to something created in 2008 discussing this very topic.

What this concept means and how it can be made a reality though has evolved and will continue to evolve as time continues as the technology to support this evolves.

What Does This Mean?

Contactless resolution means being able to resolve something without contacting a person. In other words, getting a result from self-service and without requiring involvement from another person.

This is different to proactive resolution, which is the ideal scenario and realistically this is something built upon years of experience and data. There will always be issues and requests that cannot be proactively resolved though, as people will always have questions and issues that cannot be predicted or have not been raised before.

Historically this was done through expecting a user to find a knowledge article and using the information from that knowledge article to solve their issue. Before that and outside of anything IT related, you could think of the opening times posted on the window of a local café as a method of contactless resolution.

You could go into a building to ask the opening time from a person, but in terms of contactless resolution this would mean reading a poster outside of it to get the same result.

However, as we as a species become more advance, so do our questions and issues.

As a result, the way we attempt to resolve requests without contact needs to evolve, as the added complexity in certain issues of today’s world are not answerable with the previous methods described.

Virtual Agent

This is where virtual agents come in.

A knowledge article and a poster on a window are all well and good for simple questions and queries, but it does not really evolve as the query evolve. It is a static bit of information. Also, these sources can be information overload (a bit like these blog entries some would say), so are not effective for complex questions. Imagine if you will that you are having printer issues. Historically, you would have searched in search engine with your printer make and issue and browsed around 10 websites, until you realise you do not have the permissions on your machine to be able to resolve this issue alone. Either that, or you will call the service desk, only for them to provide you a knowledge article with a step by step guide that they developed using the official website as a guide. Both “may” work but cannot evolve as your situation evolves without continual contact.

Let’s look at it from a ServiceNow virtual agent point of view.

Fortunately, your organisation has made the effort of saying what printers are assigned to what person and locations in your ServiceNow instance. You browse to your Service Portal and decide to “try” the virtual agent experience. You tell the virtual agent that the printer will not turn on and that takes you to the virtual agent topic related to printer issues. The virtual agent confirms you are working from a certain location with you and then understands that the printer you are having issues with is from a certain manufacturer (as your configuration management database is up to date and your user record says you are working from that location).

In doing this, it can provide step by step trouble shooting issues specific to that printer within a matter of seconds, simply from you typing your initial query and confirming your location. You try a few different steps and then get asked if it was able to solve your issue. It does not, however provides another solution that does. The virtual agent asks if the new recommendation helped and by saying yes, you record this information that then can be reported against to improve the virtual agent in the future.

All in all, this saves you the time of waiting on the phone waiting to talk to IT support, trying to find a website on your own and saves the service desk agent time. A simple sign may help with the opening hours of a business, but won’t help in deciphering complex issues, empowering users to solve their own issues and tracking what the common solutions are to issues to potentially proactively solve them in the future.

However, what does this mean for the service agent now that a “robot” has stolen “their job”.

Service Agent Concerns

One of the most common concerns when looking into virtual agents is how it may impact your service agents’ daily activities. It may not directly impact them, but they may feel as though that their day to day activities will change or they will simply be made redundant.

Yes, their day to day activities will change, but organisations can use this newly procured time to put their service agents to work in improving the virtual agent experience, improving their overall service experience and more importantly improving their business with this newly found time.

Service agents are just that, agents and individuals in place to provide a service to their customers. What can happen that instead of taking the same phone call day in and day out can therefore be exchanged with improving their applications to perform better and creating new services for their end users.

This will improve employee satisfaction and as a result, the retention of employees as it provides a more fulfilling job experience.

Their jobs will not be filled with mundane tasks that require data entry for the sake of data entry, Operational insights will also be more accurate to provide an even better service to their end users as it is no longer manually entered.

Although contactless resolution appears like a negative to the service agents without investigating it, it becomes a positive when it is implemented.

 

This is what really highlights the potential results you can get with a Virtual Agent at all levels of the business.

In the third part of this four-part blog series, we will discuss operational insights and accuracy.

In the meantime, check out this great Virtual Agent demo from ServiceNow.

How ServiceNow’s ‘Virtual Agent’ can assist your organisation: Part 1

Blog, ServiceNowKelly Cooke

 

This blog entry is part of a four-part blog series on how ServiceNow’s Virtual Agent can assist your organisation.

 

If you talk to someone about the present state of the IT industry, artificial intelligence, virtual agent and chatbots are topics that commonly surface in one way or another.

From forcibly having to “deal” with it while trying to raise a support query from your internet provider to something less prominent to having a popup in the bottom right part of your screen asking if there is anything they can help with.  These concepts have become front and centre in the drive to provide a better customer experience to users.

They are often get implemented with the best intentions, but when not implemented with the right strategy can turn a previously acceptable user experience, to a frustrating one where you are constantly getting distracted by notifications.

  • Is implementing a virtual agent the right thing to do?
  • Will it really provide a better experience for users?
  • Will it improve satisfaction for all members of my organisation and my customers?

In a word, yes.  This blog series will discuss four main topics that should be front and centre when talking and thinking about virtual agents for your organisation, as well as some small bits of wisdom to take on your journey.

We at JDS Australia would love to help you on this journey, and fortunately ServiceNow has a great Virtual Agent out of the box that you can utilise.

Part 1: Empowering People

When Virtual Agent comes up in conversation, the concept of empowerment comes up but normally only focusing on the end user.

In reality though, Virtual Agents help empower both sides of the coin.

What does this mean though?

How can virtual agents empower both end users, service agents and the organisation and their customers at large?

The End Users

To start, let’s start with a thought experiment.

You and everyone else reading this article is an end user somewhere.  Whether for your internet service provider, mobile provider or even as a patron of your favourite fast food chain, you have experience as an end user and will have seen an evolution in how this is done.  In your head, what do you consider a good experience? What do you consider a negative one?  What do you think would help that experience?  Fast food chains introduced self-service terminals where you can order without talking to someone and various telecommunication organisations introduced Virtual Agents, both with varying levels of success.   Now think about the place that you work or the customers that you serve.  What is something you answer day in, and day out based on a question that is commonly asked?

Frankly speaking, Virtual Agents have a bad habit of being introduced and forced onto users, whereas really it can be introduced to empower users, by offering them options and saving time.  If we investigate the last question in our thought experiment, the joke answer is “have you turned it on and off again”. It may be seen as a joke, but yes, it sometimes helps (despite our reluctance to do it before calling).

In a more complex example, what about access and permissions to an external system?  The most common response is to call up IT or ask your friendly IT support team to do it off the record, but what happens if you could do it yourself?

Various systems and applications offer a range of web services that you can hook into with ServiceNow via an integration.  Through these integrations and details you may find on a user record, you could simply automate it.  Where does Virtual Agent play into this though?  Before getting access to a system or understanding permissions, there are often a variety of questions based on the application you are speaking about.  The Virtual Agent can ask these questions first and respond based on the answers provided.  It may not necessarily remove all human interaction to make the request possible (such as requiring approvals), but it will handle the questions that need to be asked that may cancel a request before it is even raised.  Saving the time of the end user, as they no longer need to make time for a phone call and saving the time of the service agent, as they no longer have to spend the time to have the conversation, which includes the time to get back into the groove of what they were working on.  This gives the end user the feeling as they solved their own issue and provides them with the confidence to try to solve this issue first without calling the help desk.

What does this mean for the service desk agent though?  If they are not on the phone with end users, how does this empower them?  Doesn’t that make their job redundant?

The Service Agents

In a word, no.

In fact, having the various service agents involved to in the investigation of how they can better serve the end users is more important than ever.  These are the people who now can spend more time on more complex questions and fulfilling the manual requests when needed and know what is best when serving the end user.  The Virtual Agent empowers these users even more than the end users, as now they can be involved in the development and continual improvement of the Virtual Agent.  This provides the service agents the power to be directly involved in the improvement of their services to the end users but using their experience to ask the questions they need to, to get a better outcome.

That is the main opportunity for Virtual Agent when the service desk agent is directly involved.  They can help in improving the questions and topics that a Virtual Agent asks the end user, so they get the information that they need to resolve the query first time as they continually improve it.  That is what is important to note and the reason why service agents do not simply become redundant.  Implementing a Virtual Agent is not a one and done, it’s a continual process to ensure that as your understanding of your newly empowered end users improves, so the mean time to resolve tickets improves.  Up to the point that this no longer even becomes a metric for some requests, as through asking the correct questions, these issues can be resolved without even contacting the service desk.  This is a concept known as contact-less resolution and will be spoken about in more depth in the next part of this blog series.

So if the end users now feel empowered, as they are now able to solve more issues in their own time, out of hours and without picking up their phone and service agents now can focus on improving these experiences and can spend more time on more complex tasks, what does this mean for the organisation as a whole?

The Organisation

The organisation itself also is empowered as a result of this.  People now feel a sense of autonomy as they are not necessarily required to spend their work hours doing what they use to, as the Virtual Agent assists in alleviating some of the needs around this. The organisation can bring forth new initiatives to improve their service further.  The organisation can direct users down the path they need them too to achieve their goals… but the change on the organisational level is not so much about empowerment, but how the operational insights can move your organisation forward.  That topic however, will be discussed in a later part of our blog series.

What is the end goal when it comes to implementing a Virtual Agent?

How can this can be taken even further?

In the next part of this blog series, we'll cover contact-less resolution.

In the meantime, check out this great Virtual Agent demo from ServiceNow!

ServiceNow Upgrade Process

ServiceNowSam Lindsay

 

With ServiceNow committing to two major releases a year and only allowing customers to operate on n-1, having a well understood upgrade process is not a luxury, it’s a necessity.

To reduce the risk of disruption to the business during upgrades, JDS recommends organisations adopt a clearly defined strategy for upgrades.

  1. Prepare Environments
    • Back up any update sets in non-production
    • Clone production over non-production so the latest configuration and data is available for accurate testing. The clone should include the audit history and the system logs.
    • Upgrade non-production to the latest version of ServiceNow
    • If necessary, reapply update sets, although the recommendation is to suspend custom development during the upgrade process
  2. Bottom-Up Analysis—Review of the upgrade logs:
    • Review skipped updates to understand any potential impact on the upgrade. Although the focus is on skipped records from the latest upgrade, it is important to understand previous skipped records as there may be dependencies that cause complications
    • Focus upgrade testing on areas where updates have been skipped to ensure there are no adverse effects
    • Provide recommendations on where skipped records should be restored or merged to future-proof the organisation
  3. Top-Down Testing—Upgrade testing
    • End-to-end business process testing to ensure the veracity of the upgrade in non-production
      • Business involvement from SMEs (subject-matter experts) is critical to the success of upgrade testing
      • Where possible, follow previously established test cases
      • In the absence of established test cases, JDS recommends a random sample of records, following the audit history of each record and duplicating each step with a new test record (including impersonating users and replicating each of their updates)
      • Automated testing is intended to supplement manual testing
    • Integration testing
      • As much as possible, verify integration works as expected in non-production
      • Inbound email actions can be replicated by manually importing the relevant email XML record from production into non-prod and manually activating the “reprocess email” command
      • Outbound emails can be viewed in the email queue
  1. Defect identification and resolution
    • Based on the results of the previous steps, defects will be classified as
      1. Relating to the core system and therefore the responsibility of ServiceNow support
      2. Relating to the customised system and therefore the responsibility of the customer
        • Where possible, JDS will propose and implement defect resolution in consultation with the customer
        • If issues cannot be resolved, JDS will propose and implement a workaround
      3. User Acceptance Testing
        • UAT should not be confused with the upgrade testing. The bulk of end user testing should have already occurred under the upgrade testing phase. This particular UAT is intended to verify defect resolution.
        • UAT validates the issues exposed during the upgrade process have been rectified to the satisfaction of customer.
        • It is important to note that UAT need not be exhaustive as it's role is to confirm that defects exposed during upgrade testing were resolved
          • Additional defect resolution may be required if additional issues are exposed.
  1. Go Live
    • Upgrade production environment
    • Apply update sets based on the defect identification and resolution
    • Clone back to non-production environments to ensure all environments are in sync and on the latest version of ServiceNow
  2. Go Live Support
    • JDS recommends a go-live support for a period of two weeks
      • Any issues raised during the go-live warranty period will be subject to development and testing in non-prod and will require change management approval before deployment in production
      • If no issues arise, there’s time for enacting best practices and enhancements

The focus of upgrade testing is risk mitigation. The amount of time and effort spent on each of these phases will differ from one customer to the next depending on the size and complexity of their ServiceNow instance, along with the criticality of ServiceNow to their business practices.

If you want to learn more about upgrading ServiceNow, talk to JDS.

Modifying Service Portal Widgets On-The-Fly

ServiceNowSam Lindsay

 

Recently, a customer asked us to remove their Get Help catalog item from the list of Popular Items in the Service Portal because it's not really an item (it's a record producer) and it's accessed from the home page as well as being in the menu bar so it doesn't really belong under Popular Items.

The challenge was, how could this be done WITHOUT changing/modifying the widget (to avoid skipped upgrade updates)

Previously, I've written about how to manipulate portal widgets without modifying them, but that was on submission. This required modifying the widget on load, dynamically changing its contents on-the-fly without actually altering the core widget itself. The trick is to embed the OOB widget and use angular to inject the change.

As you'll see, the code is simple and yet effective, and could be repurposed for a number of other similar applications. Our custom widget acts as a wrapper around the OOB widget (which in this case is sc-category)

Widget HTML Code

<div>
   <sp-widget widget="data.remoteControlWidget"></sp-widget>
</div>

Widget Server Code

(function() {
        data.remoteControlWidget = $sp.getWidget("sc-category");
})();

Widget Client Controller Code

function($scope) {        

        var c = this;
        //We can get the angular data object of BOTH widgets
        var thisWidgetsData     = $scope.data;
        var theOtherWidgetsData = $scope.widget.data.remoteControlWidget.data;

        //Look at the remote scope.data object for sc category to see if have the item we want to hide/remove?
        theOtherWidgetsData.items.forEach(function(item, location){

               //Is our "Get Help" widget on the page?
               if(item.sys_id=='ea8accaedb0508103ea3cd051496198b'){

                       //Angular's injector invoke will allow us to change the scope within a digest
                       window.angular.element(document.body).injector().invoke(function($compile) {

                               //Now we can modify the other widgets scope and angular will do the rest
                               theOtherWidgetsData.items.splice(location,1);
                       });
               }
        })      
}

In essence, all we're doing is remotely accessing the OOB widget's angular scope and then using angular's injector to update that scope.

Although this might seem overly complex, we can look at the scope of any angular widget by holding down the Control key and right-clicking above the widget. Once we've identified what needs to change (in this case, removing an entry from an array), the rest is quite simple.

Have fun!

Custom Glide Modal Dialog Boxes in ServiceNow

ServiceNowSam Lindsay

 

Modal popups are an effective way of interacting with users when more information is required than would ordinarily be available on a screen. For example, confirming a deletion or getting more information when someone is submitting a record.

ServiceNow has a client-side API called GlideModal but the documentation is focused around displaying records or lists from ServiceNow rather than ad-hoc modal details. There are times when customers need a custom form with a few specific options.

In this example, we're going to add a UI Action button to the catalog task form so when a task is cancelled we can mark it as either:

  • Closed skipped - effectively cancelling the task
  • Closed incomplete - closing all related tasks along with the requested item itself

In this way, we're giving our users the ability to clearly determine what they're cancelling—just one particular task or the whole request.

UI Actions run code on both the client and the server, which is very handy.

The key to getting flexibility with glide modal dialogs is the renderWithContent function which allows us to craft our own HTML form and the window.whatever which allows us to intercept and interpret whatever happened on our modal window as the user interacted with the various options we gave them.

Consider the following code:

////////////////////////////////////////////////////////////////
//Client Side: Dialog box with choices
////////////////////////////////////////////////////////////////
function cancelDialog(){

   var gm = new GlideModal('cancelTask');
   //Sets the dialog title
   gm.setTitle('Cancel Task');
   //Set up valid custom HTML to be displayed
   gm.renderWithContent('<div style="padding:15px"><p>What action do you want to take?</p><p><select name="cancellation" id="taskCancellation" class="form-control"><option value="cancelOnly" role="option">Cancel this task but keep the requested item open</option><option value="cancelAll" role="option">Cancel this and all other tasks, closing the requested item</option></select></p><div style="padding:5px;float:right"><button style="padding:5px;margin-right:10px" onclick="window.changeTaskAction(this.innerHTML,jQuery(\'#taskCancellation\').val())" class="btn btn-default">Abort</button><button style="padding:5px" class="btn btn-primary" onclick="window.changeTaskAction(this.innerHTML,jQuery(\'#taskCancellation\').val())">Cancel Task</button></div></div>');

   //We'll use the windows object to ensure our code is accessible from the modal dialog
   window.changeTaskAction = function(thisButton, thisAction){

      //Close the glide modal dialog window
      gm.destroy();

      //Submit to the back-end
      if(thisButton=='Cancel Task'){
         if(thisAction=="cancelAll"){
            g_form.setValue('state',4);//Closed Incomplete -- will close the Requested Item and all other open tasks
         }else{
            g_form.setValue('state',7);//Closed Skipped -- will only close this task
         }
         //Regular ServiceNow form submission
         gsftSubmit(null, g_form.getFormElement(), 'cancel_sc_task');
      }
   };
   return false;//prevents the form from submitting when the dialog first load
}

////////////////////////////////////////////////////////////////
//Server Side: Dialog box with choices
////////////////////////////////////////////////////////////////
if (typeof window == 'undefined')
   updateTask();

function updateTask(){
   //Runs on the server
      if(current.state==7){
      //closed skipped so simply update this one record
      current.update();
   }else{
      //closed incomplete so update all associated records to close the requested item entirely
      current.update();

      //And now we'll cancel any other open tasks along with the requested item
      if(!gs.nil(current.parent)){
         //Close siblings
         var otherTasks = new GlideRecord('sc_task');
         otherTasks.addEncodedQuery('request_item='+current.request_item+'^stateIN-5,1,2');
         otherTasks.query();
         while(otherTasks.next()){
            otherTasks.state = '4';
            otherTasks.update();
         }
         //Close parent
         var ritm = new GlideRecord('sc_req_item');
         if(ritm.get(current.parent)){
            ritm.state = '4';
            ritm.stage = 'Cancelled';
            ritm.update();
         }
      }
   }
}

Our Glide Modal Dialog presents the user with two options in the browser and then executes the user’s preference on the server.

Code like this can be easily retrofitted, becoming a template for how ServiceNow interacts with users before records are saved. This code has been provided in an attachment. If for some reason the attached UI Action doesn't work for you, toggle the "isolate script" field (save it on then save it switched off) and it should run just fine.

Click here for a copy of the code: sys_ui_action Cancel Catalog Task

Happy coding.

Manipulating Service Portal Widgets Without Modifying Them

Blog, ServiceNowSam Lindsay

 

It’s common for organisations to want something a little bit more than what is on offer by ServiceNow in its service portal, but without breaking any core functionality. In this article, we’ll look at how you can manipulate an existing out-of-the-box widget WITHOUT modifying it.

One option is to clone the widget and change it but that causes your cloned version to become locked in time, so it won’t benefit from any enhancements or bug-fixes applied to the original widget by ServiceNow as versions upgrade.

A better approach is to embed the original widget INSIDE another widget and make your modifications there. In this way, you get the best of both worlds. Any changes to the widget will be automatically inherited, while you can change the behaviour of that widget at ease.

This article assumes you are confident in developing custom widgets. If you need more information on what service portal widgets are and how they work, please refer to:

Here’s how it can be done (with this code sample provided at the bottom of the article)

First, notice we’re using the sp-widget directive to embed an OOB widget, but we’re going to use an angular data object (essentially a variable) to hold the name of that widget. This gives us the flexibility to add HTML/Angular before and after the widget.

We populate this angular object in the server script. This gives us the ability to set any properties the widget might be expecting. In this case, we’re going to use the ServiceNow catalogue item widget (v2)

Now, in our client script, we can refer to data in BOTH our widget and the OOB widget, something that is extremely handy!

Finally, in this example, we’re interested to add some extra functionality when the original OOB widget is submitted. Looking at the client script for the OOB widget, we can see that ServiceNow are using broadcast events to transmit (emit) various actions. This is what we’ll intercept.

As you can see there are several events we could intercept and augment, like when a submission fails. Once we know what we’re looking for we can simply listen in the background, waiting for that event to occur.

Once that event fires, we can then choose to do something in addition to what the OOB widget is doing using both client and server code in our custom widget (and importantly, acting on information gathered by the OOB widget itself).

$scope.server.get allows us to send an action the server where it is processed and the response is returned.

In this way, we can manipulate an out-of-the-box widget provided by ServiceNow without modifying or cloning it.

Please find example XML here: sp_widget example

Virtual Agent Is Your Friend

Blog, ServiceNowJDS

Don’t underestimate the importance of user satisfaction

If there’s one defining characteristic of the social media revolution it’s “make life easy.”

Why did Facebook win out over MySpace? Facebook made it easy to connect, easy to post, easy to find people, easy to interact.

Amazon, Google, Twitter and Facebook have spent the last decade refining their technology to lower the barrier-to-entry for users, making their web applications highly accessible. Have you ever wondered why Google only shows the first ten entries for each search when it could show twenty, fifty or a hundred? Google found that 10 results returned in 0.4 sec, while 30 results took 0.9 sec, but that extra half a second lead to a loss of 20% of their traffic because users were impatient. User satisfaction is the golden rule of online services and so 10 results per page is now standard across all search engines regardless even though now days the difference is probably much less.

When it comes to ServiceNow, organisations should focus on user satisfaction as a way of increasing productivity. ServiceNow allows organisations to treat both their internal staff and their customers with respect, offering services that are snappy, intelligent and well designed. To this end, ServiceNow has developed a number of offerings including Virtual Agent.

What is Virtual Agent?

To say Virtual Agent is a chat-bot is disingenuous. Virtual Agent is a channel for users to quickly and easy get answers to their questions. It is a state-of-the-art system that leverages Natural Language Understanding (NLU) and a complex, decision-based response engine to meet a user’s expectations without wasting their time.

The Natural Language Understanding machine learning engine used by ServiceNow is trained to understand conversational chats using Wikipedia and The Washington Post, and can be enhanced with organisational specific words and phrases. Natural Language Understanding is the gateway for users to reach a catalogue of prebuilt workflows that resolve common issues.

The Virtual Agent Designer allows for sophisticated workflows with complex decision-making. Not only does this reduce the burden on first-level support it drastically reduces the resolution time for common issues, raising the satisfaction of users with the services provided by your organisation.

But the real genius behind Virtual Agent is it can be run from ANYWHERE

A common problem experienced by organisations with ServiceNow is managing multiple corporate websites. The ServiceNow self-service portal can be seen by some users as yet another corporate web instance and a bridge too far, reducing the adoption of self-service. To combat this, ServiceNow allows its Virtual Agent to be deployed ANYWHERE. As an example, it’s on this WordPress page! Go ahead, give it a try. As soon as you click on “chat”, you’re interacting with the JDSAustraliaDemo1 instance of ServiceNow!

By allowing the Virtual Agent to run from anywhere, customers can incorporate ServiceNow functionality into their other websites, giving users easy access to the services and offerings available through ServiceNow.

Keep your users happy. Start using Virtual Agent.

Using Common Functions in the Service Catalog

Blog, ServiceNowJDS

ServiceNow’s service portal offers a lot of flexibility for customers wanting to offer complex and sophisticated offerings to their users. Catalog client scripts can run on load, on change and on submit, but often there’s a need for a common library of functions to be shared by these scripts (so they’re maintained in just one place and produce consistent results).

For example, in this case, if the start date, end date or the SAP position changes, the same script needs to run to calculate who the approvers are for a particular request.

Rather than having three separate versions of the same script, we want to be able to store our logic in one place. Here’s how we can do it.

 

Isolate Script

Although the latest versions of ServiceNow (London, Madrid, etc) allow for scripts to be isolated or not, giving ServiceNow admins either the option of protecting (isolating) their scripts or accessing broader libraries, in practice, this can be a little frustrating to implement, so in our example, we’ll use an alternative method to introduce external javascript libraries.

 

UI Scripts

UI scripts, like the one listed below, are very powerful, but they’re also very broad, being applied EVERYWHERE and ALWAYS, so we’ll tread lightly and simply add a function that sets up the DOM for access from our client scripts.

As you can see, we now have some variables we can reference to give us access to the document object, the window object and the angular object from anywhere within ServiceNow.

In theory, we could attach our SAP position changes script here and it would be accessible but it would also be loaded on EVERY page ServiceNow ever loads, which is not good. What we want is a global function accessible only from WITHIN our catalog item, so we’ll put this in an ON LOAD script using our new myWindow object.

The format we’re using is…

myWindow.functionName = function(){

console.log('this is an example')

};

This function can then be called from ANYWHERE within our catalog item (on change or on submit). Also, notice the semi-colon at the end of the window function. Don’t forget this as it is important as we’re altering an object.

Now, though, any time we want to call that common function, we can do so with a single line of code.

 

Following this approach makes maintenance of the logic used by the approval process easy to find and alter going forward.

Conclusion

To learn more about how JDS can optimize the performance of ServiceNow, contact our team today on 1300 780 432, or email [email protected].

Finding Exoplanets with Splunk

Blog, Splunk, Tech TipsJDS

Splunk is a software platform designed to search, analyze and visualize machine-generated data, making sense of what, to most of us, looks like chaos.

Ordinarily, the machine data used by Splunk is gathered from websites, applications, servers, network equipment, sensors, IoT (internet-of-things) devices, etc, but there’s no limit to the complexity of data Splunk can consume.

Splunk specializes in Big Data, so why not use it to search the biggest data of all and find exoplanets?

What is an exoplanet?

An exoplanet is a planet in orbit around another star.

The first confirmed exoplanet was discovered in 1995 orbiting the star 51 Pegasi, which makes this an exciting new, emerging field of astronomy. Since then, Earth-based and space-based telescopes such as Kepler have been used to detect thousands of planets around other stars.

At first, the only planets we found were super-hot Jupiters, enormous gas giants orbiting close to their host stars. As techniques have been refined, thousands of exoplanets have been discovered at all sizes and out to distances comparable with planets in our own solar system. We have even discovered exomoons!

 

How do you find an exoplanet?

Imagine standing on stage at a rock concert, peering toward the back of the auditorium, staring straight at one of the spotlights. Now, try to figure out when a mosquito flies past that blinding light. In essence, that’s what telescopes like NASA’s TESS (Transiting Exoplanet Survey Satellite) are doing.

The dip in starlight intensity can be just a fraction of a percent, but it’s enough to signal that a planet is transiting the star.

Transits have been observed for hundreds of years in one form or another, but only recently has this idea been applied outside our solar system.

Australia has a long history of human exploration, starting some 60,000 years ago. In 1769 after (the then) Lieutenant James Cook sailed to Tahiti to observe the transit of Venus across the face of the our closest star, the Sun, he was ordered to begin a new search for the Great Southern Land which we know as Australia. Cook’s observation of the transit of Venus used largely the same technique as NASA’s Hubble, Kepler and TESS space telescopes but on a much simpler scale.

Our ability to monitor planetary transits has improved considerably since the 1700s.

NASA’s TESS orbiting telescope can cover an area 400 times as broad as NASA’s Kepler space telescope and is capable of monitoring a wider range of star types than Kepler, so we are on the verge of finding tens of thousands of exoplanets, some of which may contain life!

How can we use Splunk to find an exoplanet?

 Science thrives on open data.

All the raw information captured by both Earth-based and space-based telescopes like TESS are publicly available, but there’s a mountain of data to sift through and it’s difficult to spot needles in this celestial haystack, making this an ideal problem for Splunk to solve.

While playing with this over Christmas, I used the NASA Exoplanet Archive, and specifically the PhotoMetric data containing 642 light curves to look for exoplanets. I used wget in Linux to retrieve the raw data as text files, but it is possible to retrieve this data via web services.

MAST, the Mikulski Archive for Space Telescopes, has made available a web API that allows up to 500,000 records to be retrieved at a time using JSON format, making the data even more accessible to Splunk.

Some examples of API queries that can be run against the MAST are:

The raw data for a given observation appears as:

Information from the various telescopes does differ in format and structure, but it’s all stored in text files that can be interrogated by Splunk.

Values like the name of the star (in this case, Gliese 436) are identified in the header, while dates are stored either using HJD (Heliocentric Julian Dates) or BJD (Barycentric Julian Dates) centering on the Sun (with a difference of only 4 seconds between them).

Some observatories will use MJD which is the Modified Julian Date (being the Julian Date minus 2,400,000.5 which equates to November 17, 1858). Sounds complicated, but MJD is an attempt to simplify date calculations.

Think of HJD, BJD and MJD like UTC but for the entire solar system.

One of the challenges faced in gathering this data is that the column metadata is split over three lines, with the title, the data type and the measurement unit all appearing on separate lines.

The actual data captured by the telescope doesn’t start being displayed until line 138 (and this changes from file to file as various telescopes and observation sets have different amounts of associated metadata).

In this example, our columns are…

  • HJD - which is expressed as days, with the values beyond the decimal point being the fraction of that day when the observation occurred
  • Normalized Flux - which is the apparent brightness of the star
  • Normalized Flux Uncertainty - capturing any potential anomalies detected during the collection process that might cast doubt on the result (so long as this is insignificant it can be ignored).

Heliocentric Julian Dates (HJD) are measured from noon (instead of midnight) on 1 January 4713 BC and are represented by numbers into the millions, like 2,455,059.6261813 where the integer is the days elapsed since then, while the decimal fraction is the portion of the day. With a ratio of 0.00001 to 0.864 seconds, multiplying the fraction by 86400 will give us the seconds elapsed since noon on any given Julian Day. Confused? Well, your computer won’t be as it loves working in decimals and fractions, so although this system may seem counterintuitive, it makes date calculations simple math.

We can reverse engineer Epoch dates and regular dates from HJD/BJD, giving Splunk something to work with other than obscure heliocentric dates.

  • As Julian Dates start at noon rather than midnight, all our calculations are shifted by half a day to align with Epoch (Unix time)
  • The Julian date for the start of Epoch on CE 1970 January 1st 00:00:00.0 UT is 2440587.500000
  • Any-Julian-Date-minus-Epoch = 2455059.6261813 - 2440587.5 = 14472.12618
  • Epoch-Day = floor(Any-Julian-Date-minus-Epoch) * milliseconds-in-a-day = 14472 * 86400000 = 1250380800000
  • Epoch-Time = floor((Any-Julian-Date-minus-Epoch – floor(Any-Julian-Date-minus-Epoch)) * milliseconds-in-a-day = floor(0. 6261813 * 86400000) = 10902064
  • Observation-Epoch-Day-Time = Epoch-Day + Epoch-Time = 1250380800000 + 10902064 = 1250391702064

That might seem a little convoluted, but we now have a way of translating astronomical date/times into something Splunk can understand.

I added a bunch of date calculations like this to my props.conf file so dates would appear more naturally within Splunk.

[exoplanets]

SHOULD_LINEMERGE = false

LINE_BREAKER = ([\r\n]+)

EVAL-exo_observation_epoch = ((FLOOR(exo_HJD - 2440587.5) * 86400000) + FLOOR(((exo_HJD - 2440587.5) - FLOOR(exo_HJD - 2440587.5))  *  86400000))

EVAL-exo_observation_date = (strftime(((FLOOR(exo_HJD - 2440587.5) * 86400000) + FLOOR(((exo_HJD - 2440587.5) - FLOOR(exo_HJD - 2440587.5))  *  86400000)) / 1000,"%d/%m/%Y %H:%M:%S.%3N"))

EVAL-_time = strptime((strftime(((FLOOR(exo_HJD - 2440587.5) * 86400000) + FLOOR(((exo_HJD - 2440587.5) - FLOOR(exo_HJD - 2440587.5))  *  86400000)) / 1000,"%d/%m/%Y %H:%M:%S.%3N")),"%d/%m/%Y %H:%M:%S.%3N")

Once date conversions are in place, we can start crafting queries that map the relative flux of a star and allow us to observe exoplanets in another solar system.

Let’s look at a star with the unassuming ID 0300059.

sourcetype=exoplanets host="0300059"

| rex field=_raw "\s+(?P<exo_HJD>24\d+.\d+)\s+(?P<exo_flux>[-]?\d+.\d+)\s+(?P<exo_flux_uncertainty>[-]?\d+.\d+)" | timechart span=1s avg(exo_flux)

And there it is… an exoplanet blotting out a small fraction of starlight as it passes between us and its host star!

What about us?

While curating the Twitter account @RealScientists, Dr. Jessie Christiansen made the point that we only see planets transit stars like this if they’re orbiting on the same plane we’re observing. She also pointed out that “if you were an alien civilization looking at our solar system, and you were lined up just right, every 365 days you would see a (very tiny! 0.01%!!) dip in the brightness that would last for 10 hours or so. That would be Earth!”

There have even been direct observations of planets in orbit around stars, looking down from above (or up from beneath depending on your vantage point). With the next generation of space telescopes, like the James Webb, we’ll be able to see these in greater detail.

 

Image credit: NASA exoplanet exploration

Next steps

From here, the sky’s the limit—quite literally.

Now we’ve brought data into Splunk we can begin to examine trends over time.

Astronomy is BIG DATA in all caps. The Square Kilometer Array (SKA), which comes on line in 2020, will create more data each day than is produced on the Internet in a year!

Astronomical data is the biggest of the Big Data sets and that poses a problem for scientists. There’s so much data it is impossible to mine it all thoroughly. This has led to the emergence of citizen science, where regular people can contribute to scientific discoveries using tools like Splunk.

Most stars have multiple planets, so some complex math is required to distinguish between them, looking at the frequency, magnitude and duration of their transits to identify them individually. Over the course of billions of years, the motion of planets around a star fall into a pattern known as orbital resonance, which is something that can be predicted and tested by Splunk to distinguish between planets and even be used to predict undetected planets!

Then there’s the tantalizing possibility of exomoons orbiting exoplanets. These moons would appear as a slight dip in the transit line (similar to what’s seen above at the end of the exoplanet’s transit). But confirming the existence of an exomoon relies on repeated observations, clearly distinguished from the motion of other planets around that star. Once isolated, the transit lines should show a dip in different locations for different transits (revealing how the exomoon is swinging out to the side of the planet and increasing the amount of light being blocked at that point).

Given its strength with modelling data, predictive analytics and machine learning, Splunk is an ideal platform to support the search for exoplanets.

Find out more

If you’d like to learn more about how Splunk can help your organization reach for the stars, contact one of our account managers.

Our team on the case

Our Splunk stories

Glide Variables

ServiceNow, Tech TipsJDS

ServiceNow uses a special type of super flexible variable to store information in what appears like a single field, but is actually a complex storage/management system with a database column type called glide_var.As each record can have a different number of variables stored as key/value pairs, there’s no easy way of dot-walking to the name of the variable within the glide_var as the names can change from record to record within the same table! You can, however, detect and retrieve variables from a glide_var by treating the gliderecord field as an object.

In this example, from an automated test framework step, you can see each of the variables and their values from the database glide_var column inputs.

var gr = new GlideRecord('the table you are looking at')
gr.get('sys_id of the record you are looking at')

for(var eachVariable in gr.inputs){
gs.info(eachVariable + ' : ' + gr.inputs[eachVariable])
}

If you run this in a background script you’ll see precisely which variables exist and what their values are.

It doesn’t need to be complicated! Reach out to us and we can help you.

Governance, Risk & Compliance

Blog, ServiceNowJDS

ServiceNow has implemented Governance, Risk and Compliance (GRC) based on the OCEG (Open Compliance & Ethics Group) GRP Capability Model.

What is GRC?

  • Governance allows an organisation to reliably achieve its objectives
  • Risk addresses uncertainty in a structured manner
  • Compliance ensures business activities are undertaken with integrity

Whether organisations formally recognize GRC or not, they all need to undertake some form of governance over their business activities or they will not be able to reliably achieve their goals.

When it comes to risk, recognising and addressing uncertainty ensures the durability of an organisation before it is placed in a position where it is under stress. Public and government expectations are that organisations will act with integrity; failure to do so may result in a loss of revenue, loss of social standing and possibly government fines or loss of licensing.

Governance, Risk and Compliance is built around the authority documents, policies and risks identified by the organisation as important.

Depending on the industry, there are a number of standards authorities and government regulations that form the basis for documents of authority, providing specific compliance regulations. ISO (the International Organisation for Standardization) has established quality assurance standards such as ISO 9000, and risk management frameworks such as ISO 31000, or ISO 27000 standards for information security management.

In addition to these, various governments may demand adherence to standards developed to protect the public, such as Sarbanes-Oxley (to protect investors against possible fraud), HIPAA (the US Health Insurance Portability and Accountability Act of 1996) and GDPR (the European Union’s General Data Protection Regulation). ServiceNow’s GRC allows organisations to manage these complex requirements and ensure they are compliant and operating efficiently.

The sheer number of documents and standards, along with the complexity of how they depend on and interact with each other, can make GRC daunting to administer. ServiceNow has simplified this process by structuring these activities in a logical framework.

Authority documents (like ISO 27000), internal policies and risk frameworks (like ISO 31000) represent a corporate library—the ideal state for the organisation. The question then becomes, how well does an organisation measure up to its ideals in terms of policies and risks?

ServiceNow addresses this by using profile types.

Profile types are a means of translating polices and risks into practice.

When policy types are applied to policy statements, they form the active controls for an organisation— that is, those controls from the library that are being actively monitored.

In the same way, when risks are applied to policy types, they form the risk register for the organization. This is the definitive list of those specific risks that are being actively measured and monitored, as opposed to all risks.

This approach allows organisations to accurately measure their governance model and understand which areas they need to focus on to improve.

The metrics supporting GRC profile types can be gathered manually via audit-styled surveys of employees and third-parties, or in an automated fashion using information stored elsewhere within ServiceNow (such as IT Service Management or Human Resources). In addition to this, GRC compliance metrics for the various profile types can be gathered using orchestration and automation, and by integrating with other systems to provide an accurate view of governance, risk and compliance.

If you would like to learn more about how ServiceNow can support your organisation manage the complexity of GRC, please speak to one of our account executives.

Conclusion

It doesn’t need to be complicated! Reach out to us and we can help you manage your organizational risks.